ShuriZma
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

GSdx: more refactoring (aka search and replace) 

git-svn-id: http://pcsx2.googlecode.com/svn/trunk@1179 96395faa-99c1-11dd-bbfe-3dabce05a288
This commit is contained in:
gabest11 2009-05-14 16:41:52 +00:00
parent 40447aabc1
commit 5648d07b96
96 changed files with 4863 additions and 5676 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
plugins/GSdx/GPU.cpp
View File

@ -32,7 +32,7 @@
static HRESULT s_hr = E_FAIL; static HRESULT s_hr = E_FAIL;
static GPURendererBase* s_gpu = NULL; static GPURendererBase* s_gpu = NULL;
EXPORT_C_(UINT32) PSEgetLibType() EXPORT_C_(uint32) PSEgetLibType()
{ {
return PSE_LT_GPU; return PSE_LT_GPU;
} }
@ -42,15 +42,15 @@ EXPORT_C_(char*) PSEgetLibName()
return GSUtil::GetLibName(); return GSUtil::GetLibName();
} }
EXPORT_C_(UINT32) PSEgetLibVersion() EXPORT_C_(uint32) PSEgetLibVersion()
{ {
static const UINT32 version = 1; static const uint32 version = 1;
static const UINT32 revision = 1; static const uint32 revision = 1;
return version << 16 | revision << 8 | PLUGIN_VERSION; return version << 16 | revision << 8 | PLUGIN_VERSION;
} }
EXPORT_C_(INT32) GPUinit() EXPORT_C_(int32) GPUinit()
{ {
AFX_MANAGE_STATE(AfxGetStaticModuleState()); AFX_MANAGE_STATE(AfxGetStaticModuleState());
@ -59,7 +59,7 @@ EXPORT_C_(INT32) GPUinit()
return 0; return 0;
} }
EXPORT_C_(INT32) GPUshutdown() EXPORT_C_(int32) GPUshutdown()
{ {
AFX_MANAGE_STATE(AfxGetStaticModuleState()); AFX_MANAGE_STATE(AfxGetStaticModuleState());
@ -68,7 +68,7 @@ EXPORT_C_(INT32) GPUshutdown()
return 0; return 0;
} }
EXPORT_C_(INT32) GPUclose() EXPORT_C_(int32) GPUclose()
{ {
AFX_MANAGE_STATE(AfxGetStaticModuleState()); AFX_MANAGE_STATE(AfxGetStaticModuleState());
@ -86,7 +86,7 @@ EXPORT_C_(INT32) GPUclose()
return 0; return 0;
} }
EXPORT_C_(INT32) GPUopen(HWND hWnd) EXPORT_C_(int32) GPUopen(HWND hWnd)
{ {
AFX_MANAGE_STATE(AfxGetStaticModuleState()); AFX_MANAGE_STATE(AfxGetStaticModuleState());
@ -103,8 +103,8 @@ EXPORT_C_(INT32) GPUopen(HWND hWnd)
rs.m_dither = AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("dithering"), 1); rs.m_dither = AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("dithering"), 1);
rs.m_aspectratio = AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("AspectRatio"), 1); rs.m_aspectratio = AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("AspectRatio"), 1);
rs.m_vsync = !!AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("vsync"), FALSE); rs.m_vsync = !!AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("vsync"), FALSE);
rs.m_scale.cx = AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("scale_x"), 0); rs.m_scale.x = AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("scale_x"), 0);
rs.m_scale.cy = AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("scale_y"), 0); rs.m_scale.y = AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("scale_y"), 0);
int threads = AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("swthreads"), 1); int threads = AfxGetApp()->GetProfileInt(_T("GPUSettings"), _T("swthreads"), 1);
@ -131,7 +131,7 @@ EXPORT_C_(INT32) GPUopen(HWND hWnd)
return 0; return 0;
} }
EXPORT_C_(INT32) GPUconfigure() EXPORT_C_(int32) GPUconfigure()
{ {
AFX_MANAGE_STATE(AfxGetStaticModuleState()); AFX_MANAGE_STATE(AfxGetStaticModuleState());
@ -146,7 +146,7 @@ EXPORT_C_(INT32) GPUconfigure()
return 0; return 0;
} }
EXPORT_C_(INT32) GPUtest() EXPORT_C_(int32) GPUtest()
{ {
// TODO // TODO
@ -158,76 +158,79 @@ EXPORT_C GPUabout()
// TODO // TODO
} }
EXPORT_C GPUwriteDataMem(const BYTE* mem, UINT32 size) EXPORT_C GPUwriteDataMem(const uint8* mem, uint32 size)
{ {
s_gpu->WriteData(mem, size); s_gpu->WriteData(mem, size);
} }
EXPORT_C GPUwriteData(UINT32 data) EXPORT_C GPUwriteData(uint32 data)
{ {
s_gpu->WriteData((BYTE*)&data, 1); s_gpu->WriteData((uint8*)&data, 1);
} }
EXPORT_C GPUreadDataMem(BYTE* mem, UINT32 size) EXPORT_C GPUreadDataMem(uint8* mem, uint32 size)
{ {
s_gpu->ReadData(mem, size); s_gpu->ReadData(mem, size);
} }
EXPORT_C_(UINT32) GPUreadData() EXPORT_C_(uint32) GPUreadData()
{ {
UINT32 data = 0; uint32 data = 0;
s_gpu->ReadData((BYTE*)&data, 1); s_gpu->ReadData((uint8*)&data, 1);
return data; return data;
} }
EXPORT_C GPUwriteStatus(UINT32 status) EXPORT_C GPUwriteStatus(uint32 status)
{ {
s_gpu->WriteStatus(status); s_gpu->WriteStatus(status);
} }
EXPORT_C_(UINT32) GPUreadStatus() EXPORT_C_(uint32) GPUreadStatus()
{ {
return s_gpu->ReadStatus(); return s_gpu->ReadStatus();
} }
EXPORT_C_(UINT32) GPUdmaChain(const BYTE* mem, UINT32 addr) EXPORT_C_(uint32) GPUdmaChain(const uint8* mem, uint32 addr)
{ {
// TODO uint32 last[3];
UINT32 last[3];
memset(last, 0xff, sizeof(last)); memset(last, 0xff, sizeof(last));
do do
{ {
if(addr == last[1] || addr == last[2]) break; if(addr == last[1] || addr == last[2])
{
break;
}
(addr < last[0] ? last[1] : last[2]) = addr; (addr < last[0] ? last[1] : last[2]) = addr;
last[0] = addr; last[0] = addr;
BYTE size = mem[addr + 3]; uint8 size = mem[addr + 3];
if(size > 0) if(size > 0)
{ {
s_gpu->WriteData(&mem[addr + 4], size); s_gpu->WriteData(&mem[addr + 4], size);
} }
addr = *(UINT32*)&mem[addr] & 0xffffff; addr = *(uint32*)&mem[addr] & 0xffffff;
} }
while(addr != 0xffffff); while(addr != 0xffffff);
return 0; return 0;
} }
EXPORT_C_(UINT32) GPUgetMode() EXPORT_C_(uint32) GPUgetMode()
{ {
// TODO // TODO
return 0; return 0;
} }
EXPORT_C GPUsetMode(UINT32) EXPORT_C GPUsetMode(uint32 mode)
{ {
// TODO // TODO
} }
@ -239,7 +242,7 @@ EXPORT_C GPUupdateLace()
EXPORT_C GPUmakeSnapshot() EXPORT_C GPUmakeSnapshot()
{ {
s_gpu->MakeSnapshot("c:\\"); // TODO s_gpu->MakeSnapshot("c:/"); // TODO
} }
EXPORT_C GPUdisplayText(char* text) EXPORT_C GPUdisplayText(char* text)
@ -247,12 +250,12 @@ EXPORT_C GPUdisplayText(char* text)
// TODO // TODO
} }
EXPORT_C GPUdisplayFlags(UINT32 flags) EXPORT_C GPUdisplayFlags(uint32 flags)
{ {
// TODO // TODO
} }
EXPORT_C_(INT32) GPUfreeze(UINT32 type, GPUFreezeData* data) EXPORT_C_(int32) GPUfreeze(uint32 type, GPUFreezeData* data)
{ {
if(!data || data->version != 1) if(!data || data->version != 1)
{ {
@ -288,12 +291,12 @@ EXPORT_C_(INT32) GPUfreeze(UINT32 type, GPUFreezeData* data)
return 0; return 0;
} }
EXPORT_C GPUgetScreenPic(BYTE* mem) EXPORT_C GPUgetScreenPic(uint8* mem)
{ {
// TODO // TODO
} }
EXPORT_C GPUshowScreenPic(BYTE* mem) EXPORT_C GPUshowScreenPic(uint8* mem)
{ {
// TODO // TODO
} }

278
plugins/GSdx/GPU.h
View File

@ -33,209 +33,209 @@ enum
}; };
REG32_(GPUReg, STATUS) REG32_(GPUReg, STATUS)
UINT32 TX:4; uint32 TX:4;
UINT32 TY:1; uint32 TY:1;
UINT32 ABR:2; uint32 ABR:2;
UINT32 TP:2; uint32 TP:2;
UINT32 DTD:1; uint32 DTD:1;
UINT32 DFE:1; uint32 DFE:1;
UINT32 MD:1; uint32 MD:1;
UINT32 ME:1; uint32 ME:1;
UINT32 _PAD0:3; uint32 _PAD0:3;
UINT32 WIDTH1:1; uint32 WIDTH1:1;
UINT32 WIDTH0:2; uint32 WIDTH0:2;
UINT32 HEIGHT:1; uint32 HEIGHT:1;
UINT32 ISPAL:1; uint32 ISPAL:1;
UINT32 ISRGB24:1; uint32 ISRGB24:1;
UINT32 ISINTER:1; uint32 ISINTER:1;
UINT32 DEN:1; uint32 DEN:1;
UINT32 _PAD1:2; uint32 _PAD1:2;
UINT32 IDLE:1; uint32 IDLE:1;
UINT32 IMG:1; uint32 IMG:1;
UINT32 COM:1; uint32 COM:1;
UINT32 DMA:2; uint32 DMA:2;
UINT32 LCF:1; uint32 LCF:1;
/* /*
UINT32 TX:4; uint32 TX:4;
UINT32 TY:1; uint32 TY:1;
UINT32 ABR:2; uint32 ABR:2;
UINT32 TP:2; uint32 TP:2;
UINT32 DTD:1; uint32 DTD:1;
UINT32 DFE:1; uint32 DFE:1;
UINT32 PBW:1; uint32 PBW:1;
UINT32 PBC:1; uint32 PBC:1;
UINT32 _PAD0:3; uint32 _PAD0:3;
UINT32 HRES2:1; uint32 HRES2:1;
UINT32 HRES1:2; uint32 HRES1:2;
UINT32 VRES:1; uint32 VRES:1;
UINT32 ISPAL:1; uint32 ISPAL:1;
UINT32 ISRGB24:1; uint32 ISRGB24:1;
UINT32 ISINTER:1; uint32 ISINTER:1;
UINT32 ISSTOP:1; uint32 ISSTOP:1;
UINT32 _PAD1:1; uint32 _PAD1:1;
UINT32 DMARDY:1; uint32 DMARDY:1;
UINT32 IDIDLE:1; uint32 IDIDLE:1;
UINT32 DATARDY:1; uint32 DATARDY:1;
UINT32 ISEMPTY:1; uint32 ISEMPTY:1;
UINT32 TMODE:2; uint32 TMODE:2;
UINT32 ODE:1; uint32 ODE:1;
*/ */
REG_END REG_END
REG32_(GPUReg, PACKET) REG32_(GPUReg, PACKET)
UINT32 _PAD:24; uint32 _PAD:24;
UINT32 OPTION:5; uint32 OPTION:5;
UINT32 TYPE:3; uint32 TYPE:3;
REG_END REG_END
REG32_(GPUReg, PRIM) REG32_(GPUReg, PRIM)
UINT32 VTX:24; uint32 VTX:24;
UINT32 TGE:1; uint32 TGE:1;
UINT32 ABE:1; uint32 ABE:1;
UINT32 TME:1; uint32 TME:1;
UINT32 _PAD2:1; uint32 _PAD2:1;
UINT32 IIP:1; uint32 IIP:1;
UINT32 TYPE:3; uint32 TYPE:3;
REG_END REG_END
REG32_(GPUReg, POLYGON) REG32_(GPUReg, POLYGON)
UINT32 _PAD:24; uint32 _PAD:24;
UINT32 TGE:1; uint32 TGE:1;
UINT32 ABE:1; uint32 ABE:1;
UINT32 TME:1; uint32 TME:1;
UINT32 VTX:1; uint32 VTX:1;
UINT32 IIP:1; uint32 IIP:1;
UINT32 TYPE:3; uint32 TYPE:3;
REG_END REG_END
REG32_(GPUReg, LINE) REG32_(GPUReg, LINE)
UINT32 _PAD:24; uint32 _PAD:24;
UINT32 ZERO1:1; uint32 ZERO1:1;
UINT32 ABE:1; uint32 ABE:1;
UINT32 ZERO2:1; uint32 ZERO2:1;
UINT32 PLL:1; uint32 PLL:1;
UINT32 IIP:1; uint32 IIP:1;
UINT32 TYPE:3; uint32 TYPE:3;
REG_END REG_END
REG32_(GPUReg, SPRITE) REG32_(GPUReg, SPRITE)
UINT32 _PAD:24; uint32 _PAD:24;
UINT32 ZERO:1; uint32 ZERO:1;
UINT32 ABE:1; uint32 ABE:1;
UINT32 TME:1; uint32 TME:1;
UINT32 SIZE:2; uint32 SIZE:2;
UINT32 TYPE:3; uint32 TYPE:3;
REG_END REG_END
REG32_(GPUReg, RESET) REG32_(GPUReg, RESET)
UINT32 _PAD:32; uint32 _PAD:32;
REG_END REG_END
REG32_(GPUReg, DEN) REG32_(GPUReg, DEN)
UINT32 DEN:1; uint32 DEN:1;
UINT32 _PAD:31; uint32 _PAD:31;
REG_END REG_END
REG32_(GPUReg, DMA) REG32_(GPUReg, DMA)
UINT32 DMA:2; uint32 DMA:2;
UINT32 _PAD:30; uint32 _PAD:30;
REG_END REG_END
REG32_(GPUReg, DAREA) REG32_(GPUReg, DAREA)
UINT32 X:10; uint32 X:10;
UINT32 Y:9; uint32 Y:9;
UINT32 _PAD:13; uint32 _PAD:13;
REG_END REG_END
REG32_(GPUReg, DHRANGE) REG32_(GPUReg, DHRANGE)
UINT32 X1:12; uint32 X1:12;
UINT32 X2:12; uint32 X2:12;
UINT32 _PAD:8; uint32 _PAD:8;
REG_END REG_END
REG32_(GPUReg, DVRANGE) REG32_(GPUReg, DVRANGE)
UINT32 Y1:10; uint32 Y1:10;
UINT32 Y2:11; uint32 Y2:11;
UINT32 _PAD:11; uint32 _PAD:11;
REG_END REG_END
REG32_(GPUReg, DMODE) REG32_(GPUReg, DMODE)
UINT32 WIDTH0:2; uint32 WIDTH0:2;
UINT32 HEIGHT:1; uint32 HEIGHT:1;
UINT32 ISPAL:1; uint32 ISPAL:1;
UINT32 ISRGB24:1; uint32 ISRGB24:1;
UINT32 ISINTER:1; uint32 ISINTER:1;
UINT32 WIDTH1:1; uint32 WIDTH1:1;
UINT32 REVERSE:1; uint32 REVERSE:1;
UINT32 _PAD:24; uint32 _PAD:24;
REG_END REG_END
REG32_(GPUReg, GPUINFO) REG32_(GPUReg, GPUINFO)
UINT32 PARAM:24; uint32 PARAM:24;
UINT32 _PAD:8; uint32 _PAD:8;
REG_END REG_END
REG32_(GPUReg, MODE) REG32_(GPUReg, MODE)
UINT32 TX:4; uint32 TX:4;
UINT32 TY:1; uint32 TY:1;
UINT32 ABR:2; uint32 ABR:2;
UINT32 TP:2; uint32 TP:2;
UINT32 DTD:1; uint32 DTD:1;
UINT32 DFE:1; uint32 DFE:1;
UINT32 _PAD:21; uint32 _PAD:21;
REG_END REG_END
REG32_(GPUReg, MASK) REG32_(GPUReg, MASK)
UINT32 MD:1; uint32 MD:1;
UINT32 ME:1; uint32 ME:1;
UINT32 _PAD:30; uint32 _PAD:30;
REG_END REG_END
REG32_(GPUReg, DRAREA) REG32_(GPUReg, DRAREA)
UINT32 X:10; uint32 X:10;
UINT32 Y:10; uint32 Y:10;
UINT32 _PAD:12; uint32 _PAD:12;
REG_END REG_END
REG32_(GPUReg, DROFF) REG32_(GPUReg, DROFF)
INT32 X:11; int32 X:11;
INT32 Y:11; int32 Y:11;
INT32 _PAD:10; int32 _PAD:10;
REG_END REG_END
REG32_(GPUReg, RGB) REG32_(GPUReg, RGB)
UINT32 R:8; uint32 R:8;
UINT32 G:8; uint32 G:8;
UINT32 B:8; uint32 B:8;
UINT32 _PAD:8; uint32 _PAD:8;
REG_END REG_END
REG32_(GPUReg, XY) REG32_(GPUReg, XY)
INT32 X:11; int32 X:11;
INT32 _PAD1:5; int32 _PAD1:5;
INT32 Y:11; int32 Y:11;
INT32 _PAD2:5; int32 _PAD2:5;
REG_END REG_END
REG32_(GPUReg, UV) REG32_(GPUReg, UV)
UINT32 U:8; uint32 U:8;
UINT32 V:8; uint32 V:8;
UINT32 _PAD:16; uint32 _PAD:16;
REG_END REG_END
REG32_(GPUReg, TWIN) REG32_(GPUReg, TWIN)
UINT32 TWW:5; uint32 TWW:5;
UINT32 TWH:5; uint32 TWH:5;
UINT32 TWX:5; uint32 TWX:5;
UINT32 TWY:5; uint32 TWY:5;
UINT32 _PAD:12; uint32 _PAD:12;
REG_END REG_END
REG32_(GPUReg, CLUT) REG32_(GPUReg, CLUT)
UINT32 _PAD1:16; uint32 _PAD1:16;
UINT32 X:6; uint32 X:6;
UINT32 Y:9; uint32 Y:9;
UINT32 _PAD2:1; uint32 _PAD2:1;
REG_END REG_END
REG32_SET(GPUReg) REG32_SET(GPUReg)
@ -266,10 +266,10 @@ REG_SET_END
struct GPUFreezeData struct GPUFreezeData
{ {
UINT32 version; // == 1 uint32 version; // == 1
UINT32 status; uint32 status;
UINT32 control[256]; uint32 control[256];
UINT16 vram[1024 * 1024]; uint16 vram[1024 * 1024];
}; };
#pragma pack(pop) #pragma pack(pop)

6
plugins/GSdx/GPUDrawScanline.cpp
View File

@ -51,7 +51,7 @@ void GPUDrawScanline::BeginDraw(const GSRasterizerData* data, Functions* f)
if(m_env.sel.twin) if(m_env.sel.twin)
{ {
DWORD u, v; uint32 u, v;
u = ~(env.TWIN.TWW << 3) & 0xff; u = ~(env.TWIN.TWW << 3) & 0xff;
v = ~(env.TWIN.TWH << 3) & 0xff; v = ~(env.TWIN.TWH << 3) & 0xff;
@ -100,7 +100,7 @@ GPUDrawScanline::GPUSetupPrimMap::GPUSetupPrimMap(GPUScanlineEnvironment& env)
{ {
} }
GPUSetupPrimCodeGenerator* GPUDrawScanline::GPUSetupPrimMap::Create(DWORD key, void* ptr, size_t maxsize) GPUSetupPrimCodeGenerator* GPUDrawScanline::GPUSetupPrimMap::Create(uint32 key, void* ptr, size_t maxsize)
{ {
return new GPUSetupPrimCodeGenerator(m_env, ptr, maxsize); return new GPUSetupPrimCodeGenerator(m_env, ptr, maxsize);
} }
@ -113,7 +113,7 @@ GPUDrawScanline::GPUDrawScanlineMap::GPUDrawScanlineMap(GPUScanlineEnvironment&
{ {
} }
GPUDrawScanlineCodeGenerator* GPUDrawScanline::GPUDrawScanlineMap::Create(DWORD key, void* ptr, size_t maxsize) GPUDrawScanlineCodeGenerator* GPUDrawScanline::GPUDrawScanlineMap::Create(uint32 key, void* ptr, size_t maxsize)
{ {
return new GPUDrawScanlineCodeGenerator(m_env, ptr, maxsize); return new GPUDrawScanlineCodeGenerator(m_env, ptr, maxsize);
} }

8
plugins/GSdx/GPUDrawScanline.h
View File

@ -34,24 +34,24 @@ class GPUDrawScanline : public GSAlignedClass<16>, public IDrawScanline
// //
class GPUSetupPrimMap : public GSCodeGeneratorFunctionMap<GPUSetupPrimCodeGenerator, DWORD, SetupPrimStaticPtr> class GPUSetupPrimMap : public GSCodeGeneratorFunctionMap<GPUSetupPrimCodeGenerator, uint32, SetupPrimStaticPtr>
{ {
GPUScanlineEnvironment& m_env; GPUScanlineEnvironment& m_env;
public: public:
GPUSetupPrimMap(GPUScanlineEnvironment& env); GPUSetupPrimMap(GPUScanlineEnvironment& env);
GPUSetupPrimCodeGenerator* Create(DWORD key, void* ptr, size_t maxsize); GPUSetupPrimCodeGenerator* Create(uint32 key, void* ptr, size_t maxsize);
} m_sp; } m_sp;
// //
class GPUDrawScanlineMap : public GSCodeGeneratorFunctionMap<GPUDrawScanlineCodeGenerator, DWORD, DrawScanlineStaticPtr> class GPUDrawScanlineMap : public GSCodeGeneratorFunctionMap<GPUDrawScanlineCodeGenerator, uint32, DrawScanlineStaticPtr>
{ {
GPUScanlineEnvironment& m_env; GPUScanlineEnvironment& m_env;
public: public:
GPUDrawScanlineMap(GPUScanlineEnvironment& env); GPUDrawScanlineMap(GPUScanlineEnvironment& env);
GPUDrawScanlineCodeGenerator* Create(DWORD key, void* ptr, size_t maxsize); GPUDrawScanlineCodeGenerator* Create(uint32 key, void* ptr, size_t maxsize);
} m_ds; } m_ds;
protected: protected:

6
plugins/GSdx/GPUDrawScanlineCodeGenerator.cpp
View File

@ -119,7 +119,7 @@ void GPUDrawScanlineCodeGenerator::Init(int params)
mov(eax, dword[esp + _top]); mov(eax, dword[esp + _top]);
// WORD* fb = &m_env.vm[(top << (10 + m_env.sel.scalex)) + left]; // uint16* fb = &m_env.vm[(top << (10 + m_env.sel.scalex)) + left];
mov(edi, eax); mov(edi, eax);
shl(edi, 10 + m_env.sel.scalex); shl(edi, 10 + m_env.sel.scalex);
@ -222,7 +222,7 @@ void GPUDrawScanlineCodeGenerator::Step()
// fb += 8; // fb += 8;
add(edi, 8 * sizeof(WORD)); add(edi, 8 * sizeof(uint16));
if(m_env.sel.tme) if(m_env.sel.tme)
{ {
@ -1020,7 +1020,7 @@ const GSVector4i GPUDrawScanlineCodeGenerator::m_test[8] =
GSVector4i::zero(), GSVector4i::zero(),
}; };
__declspec(align(16)) const WORD GPUDrawScanlineCodeGenerator::m_dither[4][16] = __declspec(align(16)) const uint16 GPUDrawScanlineCodeGenerator::m_dither[4][16] =
{ {
{7, 0, 6, 1, 7, 0, 6, 1, 7, 0, 6, 1, 7, 0, 6, 1}, {7, 0, 6, 1, 7, 0, 6, 1, 7, 0, 6, 1, 7, 0, 6, 1},
{2, 5, 3, 4, 2, 5, 3, 4, 2, 5, 3, 4, 2, 5, 3, 4}, {2, 5, 3, 4, 2, 5, 3, 4, 2, 5, 3, 4, 2, 5, 3, 4},

2
plugins/GSdx/GPUDrawScanlineCodeGenerator.h
View File

@ -32,7 +32,7 @@ class GPUDrawScanlineCodeGenerator : public CodeGenerator
void operator = (const GPUDrawScanlineCodeGenerator&); void operator = (const GPUDrawScanlineCodeGenerator&);
static const GSVector4i m_test[8]; static const GSVector4i m_test[8];
static const WORD m_dither[4][16]; static const uint16 m_dither[4][16];
util::Cpu m_cpu; util::Cpu m_cpu;

8
plugins/GSdx/GPUDrawingEnvironment.h
View File

@ -55,21 +55,19 @@ public:
DVRANGE.Y2 = 256; DVRANGE.Y2 = 256;
} }
CRect GetDisplayRect() GSVector4i GetDisplayRect()
{ {
static int s_width[] = {256, 320, 512, 640, 368, 384, 512, 640}; static int s_width[] = {256, 320, 512, 640, 368, 384, 512, 640};
static int s_height[] = {240, 480}; static int s_height[] = {240, 480};
CRect r; GSVector4i r;
r.left = DAREA.X & ~7; // FIXME r.left = DAREA.X & ~7; // FIXME
r.top = DAREA.Y; r.top = DAREA.Y;
r.right = r.left + s_width[(STATUS.WIDTH1 << 2) | STATUS.WIDTH0]; r.right = r.left + s_width[(STATUS.WIDTH1 << 2) | STATUS.WIDTH0];
r.bottom = r.top + (DVRANGE.Y2 - DVRANGE.Y1) * s_height[STATUS.HEIGHT] / 240; r.bottom = r.top + (DVRANGE.Y2 - DVRANGE.Y1) * s_height[STATUS.HEIGHT] / 240;
r &= CRect(0, 0, 1024, 512); return r.rintersect(GSVector4i(0, 0, 1024, 512));
return r;
} }
int GetFPS() int GetFPS()

202
plugins/GSdx/GPULocalMemory.cpp
View File

@ -27,16 +27,16 @@ const GSVector4i GPULocalMemory::m_xxbx(0x00007c00);
const GSVector4i GPULocalMemory::m_xgxx(0x000003e0); const GSVector4i GPULocalMemory::m_xgxx(0x000003e0);
const GSVector4i GPULocalMemory::m_rxxx(0x0000001f); const GSVector4i GPULocalMemory::m_rxxx(0x0000001f);
GPULocalMemory::GPULocalMemory(const CSize& scale) GPULocalMemory::GPULocalMemory(const GSVector2i& scale)
{ {
m_scale.cx = min(max(scale.cx, 0), 2); m_scale.x = min(max(scale.x, 0), 2);
m_scale.cy = min(max(scale.cy, 0), 2); m_scale.y = min(max(scale.y, 0), 2);
// //
int size = (1 << (12 + 11)) * sizeof(WORD); int size = (1 << (12 + 11)) * sizeof(uint16);
m_vm = (WORD*)VirtualAlloc(NULL, size * 2, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); m_vm = (uint16*)VirtualAlloc(NULL, size * 2, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
memset(m_vm, 0, size); memset(m_vm, 0, size);
@ -49,7 +49,7 @@ GPULocalMemory::GPULocalMemory(const CSize& scale)
size = 256 * 256 * (1 + 1 + 4) * 32; size = 256 * 256 * (1 + 1 + 4) * 32;
m_texture.buff[0] = (BYTE*)VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); m_texture.buff[0] = (uint8*)VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
m_texture.buff[1] = m_texture.buff[0] + 256 * 256 * 32; m_texture.buff[1] = m_texture.buff[0] + 256 * 256 * 32;
m_texture.buff[2] = m_texture.buff[1] + 256 * 256 * 32; m_texture.buff[2] = m_texture.buff[1] + 256 * 256 * 32;
@ -61,8 +61,8 @@ GPULocalMemory::GPULocalMemory(const CSize& scale)
{ {
for(int x = 0; x < 16; x++, offset += 256 * 256) for(int x = 0; x < 16; x++, offset += 256 * 256)
{ {
m_texture.page[0][y][x] = &((BYTE*)m_texture.buff[0])[offset]; m_texture.page[0][y][x] = &((uint8*)m_texture.buff[0])[offset];
m_texture.page[1][y][x] = &((BYTE*)m_texture.buff[1])[offset]; m_texture.page[1][y][x] = &((uint8*)m_texture.buff[1])[offset];
} }
} }
@ -70,7 +70,7 @@ GPULocalMemory::GPULocalMemory(const CSize& scale)
{ {
for(int x = 0; x < 16; x++, offset += 256 * 256) for(int x = 0; x < 16; x++, offset += 256 * 256)
{ {
m_texture.page[2][y][x] = &((DWORD*)m_texture.buff[2])[offset]; m_texture.page[2][y][x] = &((uint32*)m_texture.buff[2])[offset];
} }
} }
} }
@ -82,18 +82,18 @@ GPULocalMemory::~GPULocalMemory()
VirtualFree(m_texture.buff[0], 0, MEM_RELEASE); VirtualFree(m_texture.buff[0], 0, MEM_RELEASE);
} }
const WORD* GPULocalMemory::GetCLUT(int tp, int cx, int cy) const uint16* GPULocalMemory::GetCLUT(int tp, int cx, int cy)
{ {
if(m_clut.dirty || m_clut.tp != tp || m_clut.cx != cx || m_clut.cy != cy) if(m_clut.dirty || m_clut.tp != tp || m_clut.cx != cx || m_clut.cy != cy)
{ {
WORD* src = GetPixelAddressScaled(cx << 4, cy); uint16* src = GetPixelAddressScaled(cx << 4, cy);
WORD* dst = m_clut.buff; uint16* dst = m_clut.buff;
if(m_scale.cx == 0) if(m_scale.x == 0)
{ {
memcpy(dst, src, (tp == 0 ? 16 : 256) * 2); memcpy(dst, src, (tp == 0 ? 16 : 256) * 2);
} }
else if(m_scale.cx == 1) else if(m_scale.x == 1)
{ {
if(tp == 0) if(tp == 0)
{ {
@ -110,7 +110,7 @@ const WORD* GPULocalMemory::GetCLUT(int tp, int cx, int cy)
} }
} }
} }
else if(m_scale.cx == 2) else if(m_scale.x == 2)
{ {
if(tp == 0) if(tp == 0)
{ {
@ -152,7 +152,7 @@ const void* GPULocalMemory::GetTexture(int tp, int tx, int ty)
void* buff = m_texture.page[tp][ty][tx]; void* buff = m_texture.page[tp][ty][tx];
UINT32 flag = 1 << tx; uint32 flag = 1 << tx;
if((m_texture.valid[tp][ty] & flag) == 0) if((m_texture.valid[tp][ty] & flag) == 0)
{ {
@ -161,16 +161,16 @@ const void* GPULocalMemory::GetTexture(int tp, int tx, int ty)
switch(tp) switch(tp)
{ {
case 0: case 0:
ReadPage4(tx, ty, (BYTE*)buff); ReadPage4(tx, ty, (uint8*)buff);
bpp = 4; bpp = 4;
break; break;
case 1: case 1:
ReadPage8(tx, ty, (BYTE*)buff); ReadPage8(tx, ty, (uint8*)buff);
bpp = 8; bpp = 8;
break; break;
case 2: case 2:
case 3: case 3:
ReadPage16(tx, ty, (WORD*)buff); ReadPage16(tx, ty, (uint16*)buff);
bpp = 16; bpp = 16;
default: default:
// FIXME: __assume(0); // vc9 generates bogus code in release mode // FIXME: __assume(0); // vc9 generates bogus code in release mode
@ -185,7 +185,7 @@ const void* GPULocalMemory::GetTexture(int tp, int tx, int ty)
return buff; return buff;
} }
void GPULocalMemory::Invalidate(const CRect& r) void GPULocalMemory::Invalidate(const GSVector4i& r)
{ {
if(!m_clut.dirty) if(!m_clut.dirty)
{ {
@ -207,7 +207,7 @@ void GPULocalMemory::Invalidate(const CRect& r)
for(int x = 0, xe = min(r.right, 1024), i = 0; x < xe; x += 64, i++) for(int x = 0, xe = min(r.right, 1024), i = 0; x < xe; x += 64, i++)
{ {
DWORD flag = 1 << i; uint32 flag = 1 << i;
if(r.left >= x + 256) continue; if(r.left >= x + 256) continue;
@ -224,14 +224,14 @@ void GPULocalMemory::Invalidate(const CRect& r)
} }
} }
void GPULocalMemory::FillRect(const CRect& r, WORD c) void GPULocalMemory::FillRect(const GSVector4i& r, uint16 c)
{ {
Invalidate(r); Invalidate(r);
WORD* RESTRICT dst = GetPixelAddressScaled(r.left, r.top); uint16* RESTRICT dst = GetPixelAddressScaled(r.left, r.top);
int w = r.Width() << m_scale.cx; int w = r.width() << m_scale.x;
int h = r.Height() << m_scale.cy; int h = r.height() << m_scale.y;
int pitch = GetWidth(); int pitch = GetWidth();
@ -244,32 +244,32 @@ void GPULocalMemory::FillRect(const CRect& r, WORD c)
} }
} }
void GPULocalMemory::WriteRect(const CRect& r, const WORD* RESTRICT src) void GPULocalMemory::WriteRect(const GSVector4i& r, const uint16* RESTRICT src)
{ {
Invalidate(r); Invalidate(r);
WORD* RESTRICT dst = GetPixelAddressScaled(r.left, r.top); uint16* RESTRICT dst = GetPixelAddressScaled(r.left, r.top);
int w = r.Width(); int w = r.width();
int h = r.Height(); int h = r.height();
int pitch = GetWidth(); int pitch = GetWidth();
if(m_scale.cx == 0) if(m_scale.x == 0)
{ {
for(int j = 0; j < h; j++, src += w) for(int j = 0; j < h; j++, src += w)
{ {
for(int k = 1 << m_scale.cy; k >= 1; k--, dst += pitch) for(int k = 1 << m_scale.y; k >= 1; k--, dst += pitch)
{ {
memcpy(dst, src, w * 2); memcpy(dst, src, w * 2);
} }
} }
} }
else if(m_scale.cx == 1) else if(m_scale.x == 1)
{ {
for(int j = 0; j < h; j++, src += w) for(int j = 0; j < h; j++, src += w)
{ {
for(int k = 1 << m_scale.cy; k >= 1; k--, dst += pitch) for(int k = 1 << m_scale.y; k >= 1; k--, dst += pitch)
{ {
for(int i = 0; i < w; i++) for(int i = 0; i < w; i++)
{ {
@ -279,11 +279,11 @@ void GPULocalMemory::WriteRect(const CRect& r, const WORD* RESTRICT src)
} }
} }
} }
else if(m_scale.cx == 2) else if(m_scale.x == 2)
{ {
for(int j = 0; j < h; j++, src += w) for(int j = 0; j < h; j++, src += w)
{ {
for(int k = 1 << m_scale.cy; k >= 1; k--, dst += pitch) for(int k = 1 << m_scale.y; k >= 1; k--, dst += pitch)
{ {
for(int i = 0; i < w; i++) for(int i = 0; i < w; i++)
{ {
@ -301,23 +301,23 @@ void GPULocalMemory::WriteRect(const CRect& r, const WORD* RESTRICT src)
} }
} }
void GPULocalMemory::ReadRect(const CRect& r, WORD* RESTRICT dst) void GPULocalMemory::ReadRect(const GSVector4i& r, uint16* RESTRICT dst)
{ {
WORD* RESTRICT src = GetPixelAddressScaled(r.left, r.top); uint16* RESTRICT src = GetPixelAddressScaled(r.left, r.top);
int w = r.Width(); int w = r.width();
int h = r.Height(); int h = r.height();
int pitch = GetWidth() << m_scale.cy; int pitch = GetWidth() << m_scale.y;
if(m_scale.cx == 0) if(m_scale.x == 0)
{ {
for(int j = 0; j < h; j++, src += pitch, dst += w) for(int j = 0; j < h; j++, src += pitch, dst += w)
{ {
memcpy(dst, src, w * 2); memcpy(dst, src, w * 2);
} }
} }
else if(m_scale.cx == 1) else if(m_scale.x == 1)
{ {
for(int j = 0; j < h; j++, src += pitch, dst += w) for(int j = 0; j < h; j++, src += pitch, dst += w)
{ {
@ -327,7 +327,7 @@ void GPULocalMemory::ReadRect(const CRect& r, WORD* RESTRICT dst)
} }
} }
} }
else if(m_scale.cx == 2) else if(m_scale.x == 2)
{ {
for(int j = 0; j < h; j++, src += pitch, dst += w) for(int j = 0; j < h; j++, src += pitch, dst += w)
{ {
@ -343,31 +343,31 @@ void GPULocalMemory::ReadRect(const CRect& r, WORD* RESTRICT dst)
} }
} }
void GPULocalMemory::MoveRect(const CPoint& src, const CPoint& dst, int w, int h) void GPULocalMemory::MoveRect(int sx, int sy, int dx, int dy, int w, int h)
{ {
Invalidate(CRect(dst, CSize(w, h))); Invalidate(GSVector4i(dx, dy, dx + w, dy + h));
WORD* s = GetPixelAddressScaled(src.x, src.y); uint16* s = GetPixelAddressScaled(sx, sy);
WORD* d = GetPixelAddressScaled(dst.x, dst.y); uint16* d = GetPixelAddressScaled(dx, dy);
w <<= m_scale.cx; w <<= m_scale.x;
h <<= m_scale.cy; h <<= m_scale.y;
int pitch = GetWidth(); int pitch = GetWidth();
for(int i = 0; i < h; i++, s += pitch, d += pitch) for(int i = 0; i < h; i++, s += pitch, d += pitch)
{ {
memcpy(d, s, w * sizeof(WORD)); memcpy(d, s, w * sizeof(uint16));
} }
} }
void GPULocalMemory::ReadPage4(int tx, int ty, BYTE* RESTRICT dst) void GPULocalMemory::ReadPage4(int tx, int ty, uint8* RESTRICT dst)
{ {
WORD* src = GetPixelAddressScaled(tx << 6, ty << 8); uint16* src = GetPixelAddressScaled(tx << 6, ty << 8);
int pitch = GetWidth() << m_scale.cy; int pitch = GetWidth() << m_scale.y;
if(m_scale.cx == 0) if(m_scale.x == 0)
{ {
for(int j = 0; j < 256; j++, src += pitch, dst += 256) for(int j = 0; j < 256; j++, src += pitch, dst += 256)
{ {
@ -380,7 +380,7 @@ void GPULocalMemory::ReadPage4(int tx, int ty, BYTE* RESTRICT dst)
} }
} }
} }
else if(m_scale.cx == 1) else if(m_scale.x == 1)
{ {
for(int j = 0; j < 256; j++, src += pitch, dst += 256) for(int j = 0; j < 256; j++, src += pitch, dst += 256)
{ {
@ -393,7 +393,7 @@ void GPULocalMemory::ReadPage4(int tx, int ty, BYTE* RESTRICT dst)
} }
} }
} }
else if(m_scale.cx == 2) else if(m_scale.x == 2)
{ {
for(int j = 0; j < 256; j++, src += pitch, dst += 256) for(int j = 0; j < 256; j++, src += pitch, dst += 256)
{ {
@ -412,36 +412,36 @@ void GPULocalMemory::ReadPage4(int tx, int ty, BYTE* RESTRICT dst)
} }
} }
void GPULocalMemory::ReadPage8(int tx, int ty, BYTE* RESTRICT dst) void GPULocalMemory::ReadPage8(int tx, int ty, uint8* RESTRICT dst)
{ {
WORD* src = GetPixelAddressScaled(tx << 6, ty << 8); uint16* src = GetPixelAddressScaled(tx << 6, ty << 8);
int pitch = GetWidth() << m_scale.cy; int pitch = GetWidth() << m_scale.y;
if(m_scale.cx == 0) if(m_scale.x == 0)
{ {
for(int j = 0; j < 256; j++, src += pitch, dst += 256) for(int j = 0; j < 256; j++, src += pitch, dst += 256)
{ {
memcpy(dst, src, 256); memcpy(dst, src, 256);
} }
} }
else if(m_scale.cx == 1) else if(m_scale.x == 1)
{ {
for(int j = 0; j < 256; j++, src += pitch, dst += 256) for(int j = 0; j < 256; j++, src += pitch, dst += 256)
{ {
for(int i = 0; i < 128; i++) for(int i = 0; i < 128; i++)
{ {
((WORD*)dst)[i] = src[i * 2]; ((uint16*)dst)[i] = src[i * 2];
} }
} }
} }
else if(m_scale.cx == 2) else if(m_scale.x == 2)
{ {
for(int j = 0; j < 256; j++, src += pitch, dst += 256) for(int j = 0; j < 256; j++, src += pitch, dst += 256)
{ {
for(int i = 0; i < 128; i++) for(int i = 0; i < 128; i++)
{ {
((WORD*)dst)[i] = src[i * 4]; ((uint16*)dst)[i] = src[i * 4];
} }
} }
} }
@ -451,20 +451,20 @@ void GPULocalMemory::ReadPage8(int tx, int ty, BYTE* RESTRICT dst)
} }
} }
void GPULocalMemory::ReadPage16(int tx, int ty, WORD* RESTRICT dst) void GPULocalMemory::ReadPage16(int tx, int ty, uint16* RESTRICT dst)
{ {
WORD* src = GetPixelAddressScaled(tx << 6, ty << 8); uint16* src = GetPixelAddressScaled(tx << 6, ty << 8);
int pitch = GetWidth() << m_scale.cy; int pitch = GetWidth() << m_scale.y;
if(m_scale.cx == 0) if(m_scale.x == 0)
{ {
for(int j = 0; j < 256; j++, src += pitch, dst += 256) for(int j = 0; j < 256; j++, src += pitch, dst += 256)
{ {
memcpy(dst, src, 512); memcpy(dst, src, 512);
} }
} }
else if(m_scale.cx == 1) else if(m_scale.x == 1)
{ {
for(int j = 0; j < 256; j++, src += pitch, dst += 256) for(int j = 0; j < 256; j++, src += pitch, dst += 256)
{ {
@ -474,7 +474,7 @@ void GPULocalMemory::ReadPage16(int tx, int ty, WORD* RESTRICT dst)
} }
} }
} }
else if(m_scale.cx == 2) else if(m_scale.x == 2)
{ {
for(int j = 0; j < 256; j++, src += pitch, dst += 256) for(int j = 0; j < 256; j++, src += pitch, dst += 256)
{ {
@ -490,9 +490,9 @@ void GPULocalMemory::ReadPage16(int tx, int ty, WORD* RESTRICT dst)
} }
} }
void GPULocalMemory::ReadFrame32(const CRect& r, DWORD* RESTRICT dst, bool rgb24) void GPULocalMemory::ReadFrame32(const GSVector4i& r, uint32* RESTRICT dst, bool rgb24)
{ {
WORD* src = GetPixelAddress(r.left, r.top); uint16* src = GetPixelAddress(r.left, r.top);
int pitch = GetWidth(); int pitch = GetWidth();
@ -500,19 +500,19 @@ void GPULocalMemory::ReadFrame32(const CRect& r, DWORD* RESTRICT dst, bool rgb24
{ {
for(int i = r.top; i < r.bottom; i++, src += pitch, dst += pitch) for(int i = r.top; i < r.bottom; i++, src += pitch, dst += pitch)
{ {
Expand24(src, dst, r.Width()); Expand24(src, dst, r.width());
} }
} }
else else
{ {
for(int i = r.top; i < r.bottom; i++, src += pitch, dst += pitch) for(int i = r.top; i < r.bottom; i++, src += pitch, dst += pitch)
{ {
Expand16(src, dst, r.Width()); Expand16(src, dst, r.width());
} }
} }
} }
void GPULocalMemory::Expand16(const WORD* RESTRICT src, DWORD* RESTRICT dst, int pixels) void GPULocalMemory::Expand16(const uint16* RESTRICT src, uint32* RESTRICT dst, int pixels)
{ {
GSVector4i rm = m_rxxx; GSVector4i rm = m_rxxx;
GSVector4i gm = m_xgxx; GSVector4i gm = m_xgxx;
@ -534,11 +534,11 @@ void GPULocalMemory::Expand16(const WORD* RESTRICT src, DWORD* RESTRICT dst, int
} }
} }
void GPULocalMemory::Expand24(const WORD* RESTRICT src, DWORD* RESTRICT dst, int pixels) void GPULocalMemory::Expand24(const uint16* RESTRICT src, uint32* RESTRICT dst, int pixels)
{ {
BYTE* s = (BYTE*)src; uint8* s = (uint8*)src;
if(m_scale.cx == 0) if(m_scale.x == 0)
{ {
for(int i = 0; i < pixels; i += 2, s += 6) for(int i = 0; i < pixels; i += 2, s += 6)
{ {
@ -546,7 +546,7 @@ void GPULocalMemory::Expand24(const WORD* RESTRICT src, DWORD* RESTRICT dst, int
dst[i + 1] = (s[5] << 16) | (s[4] << 8) | s[3]; dst[i + 1] = (s[5] << 16) | (s[4] << 8) | s[3];
} }
} }
else if(m_scale.cx == 1) else if(m_scale.x == 1)
{ {
for(int i = 0; i < pixels; i += 4, s += 12) for(int i = 0; i < pixels; i += 4, s += 12)
{ {
@ -554,7 +554,7 @@ void GPULocalMemory::Expand24(const WORD* RESTRICT src, DWORD* RESTRICT dst, int
dst[i + 2] = dst[i + 3] = (s[9] << 16) | (s[8] << 8) | s[5]; dst[i + 2] = dst[i + 3] = (s[9] << 16) | (s[8] << 8) | s[5];
} }
} }
else if(m_scale.cx == 2) else if(m_scale.x == 2)
{ {
for(int i = 0; i < pixels; i += 8, s += 24) for(int i = 0; i < pixels; i += 8, s += 24)
{ {
@ -568,12 +568,14 @@ void GPULocalMemory::Expand24(const WORD* RESTRICT src, DWORD* RESTRICT dst, int
} }
} }
void GPULocalMemory::SaveBMP(const string& path, CRect r, int tp, int cx, int cy) void GPULocalMemory::SaveBMP(const string& path, const GSVector4i& r2, int tp, int cx, int cy)
{ {
r.left <<= m_scale.cx; GSVector4i r;
r.top <<= m_scale.cy;
r.right <<= m_scale.cx; r.left = r2.left << m_scale.x;
r.bottom <<= m_scale.cy; r.top = r2.top << m_scale.y;
r.right = r2.right << m_scale.x;
r.bottom = r2.bottom << m_scale.y;
r.left &= ~1; r.left &= ~1;
r.right &= ~1; r.right &= ~1;
@ -583,8 +585,8 @@ void GPULocalMemory::SaveBMP(const string& path, CRect r, int tp, int cx, int cy
BITMAPINFOHEADER bih; BITMAPINFOHEADER bih;
memset(&bih, 0, sizeof(bih)); memset(&bih, 0, sizeof(bih));
bih.biSize = sizeof(bih); bih.biSize = sizeof(bih);
bih.biWidth = r.Width(); bih.biWidth = r.width();
bih.biHeight = r.Height(); bih.biHeight = r.height();
bih.biPlanes = 1; bih.biPlanes = 1;
bih.biBitCount = 32; bih.biBitCount = 32;
bih.biCompression = BI_RGB; bih.biCompression = BI_RGB;
@ -602,10 +604,10 @@ void GPULocalMemory::SaveBMP(const string& path, CRect r, int tp, int cx, int cy
int pitch = GetWidth(); int pitch = GetWidth();
WORD* buff = (WORD*)_aligned_malloc(pitch * sizeof(WORD), 16); uint16* buff = (uint16*)_aligned_malloc(pitch * sizeof(WORD), 16);
DWORD* buff32 = (DWORD*)_aligned_malloc(pitch * sizeof(DWORD), 16); uint32* buff32 = (uint32*)_aligned_malloc(pitch * sizeof(uint32), 16);
WORD* src = GetPixelAddress(r.left, r.bottom - 1); uint16* src = GetPixelAddress(r.left, r.bottom - 1);
const WORD* clut = GetCLUT(tp, cx, cy); const uint16* clut = GetCLUT(tp, cx, cy);
for(int j = r.bottom - 1; j >= r.top; j--, src -= pitch) for(int j = r.bottom - 1; j >= r.top; j--, src -= pitch)
{ {
@ -613,26 +615,26 @@ void GPULocalMemory::SaveBMP(const string& path, CRect r, int tp, int cx, int cy
{ {
case 0: // 4 bpp case 0: // 4 bpp
for(int i = 0, k = r.Width() / 2; i < k; i++) for(int i = 0, k = r.width() / 2; i < k; i++)
{ {
buff[i * 2 + 0] = clut[((BYTE*)src)[i] & 0xf]; buff[i * 2 + 0] = clut[((uint8*)src)[i] & 0xf];
buff[i * 2 + 1] = clut[((BYTE*)src)[i] >> 4]; buff[i * 2 + 1] = clut[((uint8*)src)[i] >> 4];
} }
break; break;
case 1: // 8 bpp case 1: // 8 bpp
for(int i = 0, k = r.Width(); i < k; i++) for(int i = 0, k = r.width(); i < k; i++)
{ {
buff[i] = clut[((BYTE*)src)[i]]; buff[i] = clut[((uint8*)src)[i]];
} }
break; break;
case 2: // 16 bpp; case 2: // 16 bpp;
for(int i = 0, k = r.Width(); i < k; i++) for(int i = 0, k = r.width(); i < k; i++)
{ {
buff[i] = src[i]; buff[i] = src[i];
} }
@ -646,14 +648,14 @@ void GPULocalMemory::SaveBMP(const string& path, CRect r, int tp, int cx, int cy
break; break;
} }
Expand16(buff, buff32, r.Width()); Expand16(buff, buff32, r.width());
for(int i = 0, k = r.Width(); i < k; i++) for(int i = 0, k = r.width(); i < k; i++)
{ {
buff32[i] = (buff32[i] & 0xff00ff00) | ((buff32[i] & 0x00ff0000) >> 16) | ((buff32[i] & 0x000000ff) << 16); buff32[i] = (buff32[i] & 0xff00ff00) | ((buff32[i] & 0x00ff0000) >> 16) | ((buff32[i] & 0x000000ff) << 16);
} }
fwrite(buff32, 1, r.Width() * 4, fp); fwrite(buff32, 1, r.width() * 4, fp);
} }
_aligned_free(buff); _aligned_free(buff);

49
plugins/GSdx/GPULocalMemory.h
View File

@ -31,55 +31,56 @@ class GPULocalMemory
static const GSVector4i m_xgxx; static const GSVector4i m_xgxx;
static const GSVector4i m_rxxx; static const GSVector4i m_rxxx;
WORD* m_vm; uint16* m_vm;
struct struct
{ {
WORD* buff; uint16* buff;
int tp, cx, cy; int tp, cx, cy;
bool dirty; bool dirty;
} m_clut; } m_clut;
struct struct
{ {
BYTE* buff[3]; uint8* buff[3];
void* page[3][2][16]; void* page[3][2][16];
WORD valid[3][2]; uint16 valid[3][2];
} m_texture; } m_texture;
CSize m_scale; GSVector2i m_scale;
public: public:
GPULocalMemory(const CSize& scale); GPULocalMemory(const GSVector2i& scale);
virtual ~GPULocalMemory(); virtual ~GPULocalMemory();
CSize GetScale() {return m_scale;} GSVector2i GetScale() {return m_scale;}
int GetWidth() {return 1 << (10 + m_scale.cx);}
int GetHeight() {return 1 << (9 + m_scale.cy);}
WORD* GetPixelAddress(int x, int y) const {return &m_vm[(y << (10 + m_scale.cx)) + x];} int GetWidth() {return 1 << (10 + m_scale.x);}
WORD* GetPixelAddressScaled(int x, int y) const {return &m_vm[((y << m_scale.cy) << (10 + m_scale.cx)) + (x << m_scale.cx)];} int GetHeight() {return 1 << (9 + m_scale.y);}
const WORD* GetCLUT(int tp, int cx, int cy); uint16* GetPixelAddress(int x, int y) const {return &m_vm[(y << (10 + m_scale.x)) + x];}
uint16* GetPixelAddressScaled(int x, int y) const {return &m_vm[((y << m_scale.y) << (10 + m_scale.x)) + (x << m_scale.x)];}
const uint16* GetCLUT(int tp, int cx, int cy);
const void* GetTexture(int tp, int tx, int ty); const void* GetTexture(int tp, int tx, int ty);
void Invalidate(const CRect& r); void Invalidate(const GSVector4i& r);
void FillRect(const CRect& r, WORD c); void FillRect(const GSVector4i& r, uint16 c);
void WriteRect(const CRect& r, const WORD* RESTRICT src); void WriteRect(const GSVector4i& r, const uint16* RESTRICT src);
void ReadRect(const CRect& r, WORD* RESTRICT dst); void ReadRect(const GSVector4i& r, uint16* RESTRICT dst);
void MoveRect(const CPoint& src, const CPoint& dst, int w, int h); void MoveRect(int sx, int sy, int dx, int dy, int w, int h);
void ReadPage4(int tx, int ty, BYTE* RESTRICT dst); void ReadPage4(int tx, int ty, uint8* RESTRICT dst);
void ReadPage8(int tx, int ty, BYTE* RESTRICT dst); void ReadPage8(int tx, int ty, uint8* RESTRICT dst);
void ReadPage16(int tx, int ty, WORD* RESTRICT dst); void ReadPage16(int tx, int ty, uint16* RESTRICT dst);
void ReadFrame32(const CRect& r, DWORD* RESTRICT dst, bool rgb24); void ReadFrame32(const GSVector4i& r, uint32* RESTRICT dst, bool rgb24);
void Expand16(const WORD* RESTRICT src, DWORD* RESTRICT dst, int pixels); void Expand16(const uint16* RESTRICT src, uint32* RESTRICT dst, int pixels);
void Expand24(const WORD* RESTRICT src, DWORD* RESTRICT dst, int pixels); void Expand24(const uint16* RESTRICT src, uint32* RESTRICT dst, int pixels);
void SaveBMP(const string& path, CRect r, int tp, int cx, int cy); void SaveBMP(const string& path, const GSVector4i& r, int tp, int cx, int cy);
}; };
#pragma warning(default: 4244) #pragma warning(default: 4244)

29
plugins/GSdx/GPURenderer.h
View File

@ -30,7 +30,7 @@ struct GPURendererSettings
int m_dither; int m_dither;
int m_aspectratio; int m_aspectratio;
bool m_vsync; bool m_vsync;
CSize m_scale; GSVector2i m_scale;
}; };
class GPURendererBase : public GPUState, protected GPURendererSettings class GPURendererBase : public GPUState, protected GPURendererSettings
@ -142,7 +142,7 @@ protected:
void VertexKick() void VertexKick()
{ {
if(m_vl.GetCount() < m_env.PRIM.VTX) if(m_vl.GetCount() < (int)m_env.PRIM.VTX)
{ {
return; return;
} }
@ -214,7 +214,7 @@ protected:
if(m_env.PRIM.TME) if(m_env.PRIM.TME)
{ {
CRect r; GSVector4i r;
r.left = m_env.STATUS.TX << 6; r.left = m_env.STATUS.TX << 6;
r.top = m_env.STATUS.TY << 8; r.top = m_env.STATUS.TY << 8;
@ -246,10 +246,7 @@ protected:
return false; return false;
} }
CSize s; GSVector2i s = st[0].GetSize();
s.cx = st[0].GetWidth();
s.cy = st[0].GetHeight();
GSVector4 sr[2]; GSVector4 sr[2];
@ -262,8 +259,8 @@ protected:
dr[0].x = 0; dr[0].x = 0;
dr[0].y = 0; dr[0].y = 0;
dr[0].z = (float)s.cx; dr[0].z = (float)s.x;
dr[0].w = (float)s.cy; dr[0].w = (float)s.y;
GSVector4 c(0, 0, 0, 1); GSVector4 c(0, 0, 0, 1);
@ -345,10 +342,10 @@ public:
double fps = 1000.0f / m_perfmon.Get(GSPerfMon::Frame); double fps = 1000.0f / m_perfmon.Get(GSPerfMon::Frame);
CRect r = m_env.GetDisplayRect(); GSVector4i r = m_env.GetDisplayRect();
int w = r.Width() << m_scale.cx; int w = r.width() << m_scale.x;
int h = r.Height() << m_scale.cy; int h = r.height() << m_scale.y;
s_stats = format( s_stats = format(
"%I64d | %d x %d | %.2f fps (%d%%) | %d/%d | %d%% CPU | %.2f | %.2f", "%I64d | %d x %d | %.2f fps (%d%%) | %d/%d | %d%% CPU | %.2f | %.2f",
@ -375,13 +372,11 @@ public:
ResetDevice(); ResetDevice();
} }
CRect r; GSVector4i r;
GetClientRect(m_hWnd, &r); GetClientRect(m_hWnd, r);
GSUtil::FitRect(r, m_aspectratio); m_dev.Present(r.fit(m_aspectratio));
m_dev.Present(r);
} }
virtual bool MakeSnapshot(const string& path) virtual bool MakeSnapshot(const string& path)

55
plugins/GSdx/GPURendererSW.h
View File

@ -38,31 +38,32 @@ protected:
bool GetOutput(Texture& t) bool GetOutput(Texture& t)
{ {
CRect r = m_env.GetDisplayRect(); GSVector4i r = m_env.GetDisplayRect();
r.left <<= m_scale.cx; r.left <<= m_scale.x;
r.top <<= m_scale.cy; r.top <<= m_scale.y;
r.right <<= m_scale.cx; r.right <<= m_scale.x;
r.bottom <<= m_scale.cy; r.bottom <<= m_scale.y;
// TODO // TODO
static DWORD* buff = (DWORD*)_aligned_malloc(m_mem.GetWidth() * m_mem.GetHeight() * sizeof(DWORD), 16); static uint32* buff = (uint32*)_aligned_malloc(m_mem.GetWidth() * m_mem.GetHeight() * sizeof(uint32), 16);
m_mem.ReadFrame32(r, buff, !!m_env.STATUS.ISRGB24); m_mem.ReadFrame32(r, buff, !!m_env.STATUS.ISRGB24);
r.OffsetRect(-r.TopLeft()); int w = r.width();
int h = r.height();
if(m_texture.GetWidth() != r.Width() || m_texture.GetHeight() != r.Height()) if(m_texture.GetWidth() != w || m_texture.GetHeight() != h)
{ {
m_texture = Texture(); m_texture = Texture();
} }
if(!m_texture && !m_dev.CreateTexture(m_texture, r.Width(), r.Height())) if(!m_texture && !m_dev.CreateTexture(m_texture, w, h))
{ {
return false; return false;
} }
m_texture.Update(r, buff, m_mem.GetWidth() * sizeof(DWORD)); m_texture.Update(GSVector4i(0, 0, w, h), buff, m_mem.GetWidth() * sizeof(uint32));
t = m_texture; t = m_texture;
@ -75,8 +76,8 @@ protected:
// TODO: x/y + off.x/y should wrap around at +/-1024 // TODO: x/y + off.x/y should wrap around at +/-1024
int x = (int)(m_v.XY.X + m_env.DROFF.X) << m_scale.cx; int x = (int)(m_v.XY.X + m_env.DROFF.X) << m_scale.x;
int y = (int)(m_v.XY.Y + m_env.DROFF.Y) << m_scale.cy; int y = (int)(m_v.XY.Y + m_env.DROFF.Y) << m_scale.y;
int s = m_v.UV.X; int s = m_v.UV.X;
int t = m_v.UV.Y; int t = m_v.UV.Y;
@ -85,7 +86,7 @@ protected:
v.p = pt.xyxy(GSVector4::zero()); v.p = pt.xyxy(GSVector4::zero());
v.t = (pt.zwzw(GSVector4::zero()) + GSVector4(0.125f)) * 256.0f; v.t = (pt.zwzw(GSVector4::zero()) + GSVector4(0.125f)) * 256.0f;
v.c = GSVector4((DWORD)m_v.RGB.ai32) * 128.0f; v.c = GSVector4(m_v.RGB.u32) * 128.0f;
__super::VertexKick(); __super::VertexKick();
} }
@ -107,14 +108,14 @@ protected:
GSVector4i GetScissor() GSVector4i GetScissor()
{ {
GSVector4i v; GSVector4i r;
v.x = (int)m_env.DRAREATL.X << m_scale.cx; r.left = (int)m_env.DRAREATL.X << m_scale.x;
v.y = (int)m_env.DRAREATL.Y << m_scale.cy; r.top = (int)m_env.DRAREATL.Y << m_scale.y;
v.z = min((int)(m_env.DRAREABR.X + 1) << m_scale.cx, m_mem.GetWidth()); r.right = min((int)(m_env.DRAREABR.X + 1) << m_scale.x, m_mem.GetWidth());
v.w = min((int)(m_env.DRAREABR.Y + 1) << m_scale.cy, m_mem.GetHeight()); r.bottom = min((int)(m_env.DRAREABR.Y + 1) << m_scale.y, m_mem.GetHeight());
return v; return r;
} }
void Draw() void Draw()
@ -141,7 +142,7 @@ protected:
{ {
p.sel.tme = env.PRIM.TME; p.sel.tme = env.PRIM.TME;
p.sel.tlu = env.STATUS.TP < 2; p.sel.tlu = env.STATUS.TP < 2;
p.sel.twin = (env.TWIN.ai32 & 0xfffff) != 0; p.sel.twin = (env.TWIN.u32 & 0xfffff) != 0;
p.sel.ltf = m_filter == 1 && env.PRIM.TYPE == GPU_POLYGON || m_filter == 2 ? 1 : 0; p.sel.ltf = m_filter == 1 && env.PRIM.TYPE == GPU_POLYGON || m_filter == 2 ? 1 : 0;
const void* t = m_mem.GetTexture(env.STATUS.TP, env.STATUS.TX, env.STATUS.TY); const void* t = m_mem.GetTexture(env.STATUS.TP, env.STATUS.TX, env.STATUS.TY);
@ -155,7 +156,7 @@ protected:
p.sel.dtd = m_dither ? env.STATUS.DTD : 0; p.sel.dtd = m_dither ? env.STATUS.DTD : 0;
p.sel.md = env.STATUS.MD; p.sel.md = env.STATUS.MD;
p.sel.sprite = env.PRIM.TYPE == GPU_SPRITE; p.sel.sprite = env.PRIM.TYPE == GPU_SPRITE;
p.sel.scalex = m_mem.GetScale().cx; p.sel.scalex = m_mem.GetScale().x;
// //
@ -198,14 +199,12 @@ protected:
br = br.maxv(p); br = br.maxv(p);
} }
GSVector4i scissor = data.scissor; GSVector4i r = GSVector4i(tl.xyxy(br)).rintersect(data.scissor);
CRect r; r.left >>= m_scale.x;
r.top >>= m_scale.y;
r.left = max(scissor.x, min(scissor.z, (int)tl.x)) >> m_scale.cx; r.right >>= m_scale.x;
r.top = max(scissor.y, min(scissor.w, (int)tl.y)) >> m_scale.cy; r.bottom >>= m_scale.y;
r.right = max(scissor.x, min(scissor.z, (int)br.x)) >> m_scale.cx;
r.bottom = max(scissor.y, min(scissor.w, (int)br.y)) >> m_scale.cy;
Invalidate(r); Invalidate(r);
} }

43
plugins/GSdx/GPUScanlineEnvironment.h
View File

@ -28,32 +28,32 @@ union GPUScanlineSelector
{ {
struct struct
{ {
DWORD iip:1; // 0 uint32 iip:1; // 0
DWORD me:1; // 1 uint32 me:1; // 1
DWORD abe:1; // 2 uint32 abe:1; // 2
DWORD abr:2; // 3 uint32 abr:2; // 3
DWORD tge:1; // 5 uint32 tge:1; // 5
DWORD tme:1; // 6 uint32 tme:1; // 6
DWORD twin:1; // 7 uint32 twin:1; // 7
DWORD tlu:1; // 8 uint32 tlu:1; // 8
DWORD dtd:1; // 9 uint32 dtd:1; // 9
DWORD ltf:1; // 10 uint32 ltf:1; // 10
DWORD md:1; // 11 uint32 md:1; // 11
DWORD sprite:1; // 12 uint32 sprite:1; // 12
DWORD scalex:2; // 13 uint32 scalex:2; // 13
}; };
struct struct
{ {
DWORD _pad1:1; // 0 uint32 _pad1:1; // 0
DWORD rfb:2; // 1 uint32 rfb:2; // 1
DWORD _pad2:2; // 3 uint32 _pad2:2; // 3
DWORD tfx:2; // 5 uint32 tfx:2; // 5
}; };
DWORD key; uint32 key;
operator DWORD() {return key;} operator uint32() {return key;}
}; };
__declspec(align(16)) struct GPUScanlineParam __declspec(align(16)) struct GPUScanlineParam
@ -61,17 +61,16 @@ __declspec(align(16)) struct GPUScanlineParam
GPUScanlineSelector sel; GPUScanlineSelector sel;
const void* tex; const void* tex;
const WORD* clut; const uint16* clut;
}; };
__declspec(align(16)) struct GPUScanlineEnvironment __declspec(align(16)) struct GPUScanlineEnvironment
{ {
GPUScanlineSelector sel; GPUScanlineSelector sel;
// GPULocalMemory* mem; // TODO: obsolite
void* vm; void* vm;
const void* tex; const void* tex;
const WORD* clut; const uint16* clut;
// GSVector4i md; // similar to gs fba // GSVector4i md; // similar to gs fba

10
plugins/GSdx/GPUSettingsDlg.cpp
View File

@ -154,13 +154,13 @@ BOOL GPUSettingsDlg::OnInitDialog()
if(CComPtr<IDirect3D9> d3d = Direct3DCreate9(D3D_SDK_VERSION)) if(CComPtr<IDirect3D9> d3d = Direct3DCreate9(D3D_SDK_VERSION))
{ {
UINT ModeWidth = pApp->GetProfileInt(_T("Settings"), _T("ModeWidth"), 0); uint32 ModeWidth = pApp->GetProfileInt(_T("Settings"), _T("ModeWidth"), 0);
UINT ModeHeight = pApp->GetProfileInt(_T("Settings"), _T("ModeHeight"), 0); uint32 ModeHeight = pApp->GetProfileInt(_T("Settings"), _T("ModeHeight"), 0);
UINT ModeRefreshRate = pApp->GetProfileInt(_T("Settings"), _T("ModeRefreshRate"), 0); uint32 ModeRefreshRate = pApp->GetProfileInt(_T("Settings"), _T("ModeRefreshRate"), 0);
UINT nModes = d3d->GetAdapterModeCount(D3DADAPTER_DEFAULT, D3DFMT_X8R8G8B8); uint32 nModes = d3d->GetAdapterModeCount(D3DADAPTER_DEFAULT, D3DFMT_X8R8G8B8);
for(UINT i = 0; i < nModes; i++) for(uint32 i = 0; i < nModes; i++)
{ {
D3DDISPLAYMODE mode; D3DDISPLAYMODE mode;

96
plugins/GSdx/GPUState.cpp
View File

@ -22,7 +22,7 @@
#include "stdafx.h" #include "stdafx.h"
#include "GPUState.h" #include "GPUState.h"
GPUState::GPUState(const CSize& scale) GPUState::GPUState(const GSVector2i& scale)
: m_mem(scale) : m_mem(scale)
, s_n(0) , s_n(0)
{ {
@ -64,7 +64,7 @@ void GPUState::Reset()
{ {
m_env.Reset(); m_env.Reset();
m_mem.Invalidate(CRect(0, 0, 1024, 512)); m_mem.Invalidate(GSVector4i(0, 0, 1024, 512));
memset(&m_v, 0, sizeof(m_v)); memset(&m_v, 0, sizeof(m_v));
} }
@ -88,18 +88,18 @@ void GPUState::SetPrim(GPUReg* r)
switch(r->PRIM.TYPE) switch(r->PRIM.TYPE)
{ {
case GPU_POLYGON: case GPU_POLYGON:
PRIM.ai32 = (r->PRIM.ai32 & 0xF7000000) | 3; // TYPE IIP TME ABE TGE PRIM.u32 = (r->PRIM.u32 & 0xF7000000) | 3; // TYPE IIP TME ABE TGE
break; break;
case GPU_LINE: case GPU_LINE:
PRIM.ai32 = (r->PRIM.ai32 & 0xF2000000) | 2; // TYPE IIP ABE PRIM.u32 = (r->PRIM.u32 & 0xF2000000) | 2; // TYPE IIP ABE
PRIM.TGE = 1; // ? PRIM.TGE = 1; // ?
break; break;
case GPU_SPRITE: case GPU_SPRITE:
PRIM.ai32 = (r->PRIM.ai32 & 0xE7000000) | 2; // TYPE TME ABE TGE PRIM.u32 = (r->PRIM.u32 & 0xE7000000) | 2; // TYPE TME ABE TGE
break; break;
} }
if(m_env.PRIM.ai32 != PRIM.ai32) if(m_env.PRIM.u32 != PRIM.u32)
{ {
Flush(); Flush();
@ -109,38 +109,38 @@ void GPUState::SetPrim(GPUReg* r)
void GPUState::SetCLUT(GPUReg* r) void GPUState::SetCLUT(GPUReg* r)
{ {
UINT32 mask = 0xFFFF0000; // X Y uint32 mask = 0xFFFF0000; // X Y
UINT32 value = (m_env.CLUT.ai32 & ~mask) | (r->ai32 & mask); uint32 value = (m_env.CLUT.u32 & ~mask) | (r->u32 & mask);
if(m_env.CLUT.ai32 != value) if(m_env.CLUT.u32 != value)
{ {
Flush(); Flush();
m_env.CLUT.ai32 = value; m_env.CLUT.u32 = value;
} }
} }
void GPUState::SetTPAGE(GPUReg* r) void GPUState::SetTPAGE(GPUReg* r)
{ {
UINT32 mask = 0x000001FF; // TP ABR TY TX uint32 mask = 0x000001FF; // TP ABR TY TX
UINT32 value = (m_env.STATUS.ai32 & ~mask) | ((r->ai32 >> 16) & mask); uint32 value = (m_env.STATUS.u32 & ~mask) | ((r->u32 >> 16) & mask);
if(m_env.STATUS.ai32 != value) if(m_env.STATUS.u32 != value)
{ {
Flush(); Flush();
m_env.STATUS.ai32 = value; m_env.STATUS.u32 = value;
} }
} }
void GPUState::Invalidate(const CRect& r) void GPUState::Invalidate(const GSVector4i& r)
{ {
m_mem.Invalidate(r); m_mem.Invalidate(r);
} }
void GPUState::WriteData(const BYTE* mem, UINT32 size) void GPUState::WriteData(const uint8* mem, uint32 size)
{ {
GSPerfMonAutoTimer pmat(m_perfmon); GSPerfMonAutoTimer pmat(m_perfmon);
@ -164,7 +164,7 @@ void GPUState::WriteData(const BYTE* mem, UINT32 size)
m_write.Remove(i); m_write.Remove(i);
} }
void GPUState::ReadData(BYTE* mem, UINT32 size) void GPUState::ReadData(uint8* mem, uint32 size)
{ {
GSPerfMonAutoTimer pmat(m_perfmon); GSPerfMonAutoTimer pmat(m_perfmon);
@ -193,38 +193,38 @@ void GPUState::ReadData(BYTE* mem, UINT32 size)
} }
} }
void GPUState::WriteStatus(UINT32 status) void GPUState::WriteStatus(uint32 status)
{ {
GSPerfMonAutoTimer pmat(m_perfmon); GSPerfMonAutoTimer pmat(m_perfmon);
UINT32 b = status >> 24; uint32 b = status >> 24;
m_status[b] = status; m_status[b] = status;
(this->*m_fpGPUStatusCommandHandlers[b])((GPUReg*)&status); (this->*m_fpGPUStatusCommandHandlers[b])((GPUReg*)&status);
} }
UINT32 GPUState::ReadStatus() uint32 GPUState::ReadStatus()
{ {
GSPerfMonAutoTimer pmat(m_perfmon); GSPerfMonAutoTimer pmat(m_perfmon);
m_env.STATUS.LCF = ~m_env.STATUS.LCF; // ? m_env.STATUS.LCF = ~m_env.STATUS.LCF; // ?
return m_env.STATUS.ai32; return m_env.STATUS.u32;
} }
void GPUState::Freeze(GPUFreezeData* data) void GPUState::Freeze(GPUFreezeData* data)
{ {
data->status = m_env.STATUS.ai32; data->status = m_env.STATUS.u32;
memcpy(data->control, m_status, 256 * 4); memcpy(data->control, m_status, 256 * 4);
m_mem.ReadRect(CRect(0, 0, 1024, 512), data->vram); m_mem.ReadRect(GSVector4i(0, 0, 1024, 512), data->vram);
} }
void GPUState::Defrost(const GPUFreezeData* data) void GPUState::Defrost(const GPUFreezeData* data)
{ {
m_env.STATUS.ai32 = data->status; m_env.STATUS.u32 = data->status;
memcpy(m_status, data->control, 256 * 4); memcpy(m_status, data->control, 256 * 4);
m_mem.WriteRect(CRect(0, 0, 1024, 512), data->vram); m_mem.WriteRect(GSVector4i(0, 0, 1024, 512), data->vram);
for(int i = 0; i <= 8; i++) for(int i = 0; i <= 8; i++)
{ {
@ -289,24 +289,24 @@ void GPUState::SCH_DisplayMode(GPUReg* r)
void GPUState::SCH_GPUInfo(GPUReg* r) void GPUState::SCH_GPUInfo(GPUReg* r)
{ {
UINT32 value = 0; uint32 value = 0;
switch(r->GPUINFO.PARAM) switch(r->GPUINFO.PARAM)
{ {
case 0x2: case 0x2:
value = m_env.TWIN.ai32; value = m_env.TWIN.u32;
break; break;
case 0x0: case 0x0:
case 0x1: case 0x1:
case 0x3: case 0x3:
value = m_env.DRAREATL.ai32; value = m_env.DRAREATL.u32;
break; break;
case 0x4: case 0x4:
value = m_env.DRAREABR.ai32; value = m_env.DRAREABR.u32;
break; break;
case 0x5: case 0x5:
case 0x6: case 0x6:
value = m_env.DROFF.ai32; value = m_env.DROFF.u32;
break; break;
case 0x7: case 0x7:
value = 2; value = 2;
@ -321,7 +321,7 @@ void GPUState::SCH_GPUInfo(GPUReg* r)
} }
m_read.RemoveAll(); m_read.RemoveAll();
m_read.Append((BYTE*)&value, 4); m_read.Append((uint8*)&value, 4);
m_read.cur = 0; m_read.cur = 0;
} }
@ -343,14 +343,14 @@ int GPUState::PH_Command(GPUReg* r, int size)
Flush(); Flush();
CRect r2; GSVector4i r2;
r2.left = r[1].XY.X; r2.left = r[1].XY.X;
r2.top = r[1].XY.Y; r2.top = r[1].XY.Y;
r2.right = r2.left + r[2].XY.X; r2.right = r2.left + r[2].XY.X;
r2.bottom = r2.top + r[2].XY.Y; r2.bottom = r2.top + r[2].XY.Y;
WORD c = (WORD)(((r[0].RGB.R >> 3) << 10) | ((r[0].RGB.R >> 3) << 5) | (r[0].RGB.R >> 3)); uint16 c = (uint16)(((r[0].RGB.R >> 3) << 10) | ((r[0].RGB.R >> 3) << 5) | (r[0].RGB.R >> 3));
m_mem.FillRect(r2, c); m_mem.FillRect(r2, c);
@ -439,7 +439,7 @@ int GPUState::PH_Line(GPUReg* r, int size)
for(int i = 1; i < size; i++) for(int i = 1; i < size; i++)
{ {
if(r[i].ai32 == 0x55555555) if(r[i].u32 == 0x55555555)
{ {
vertices = i - 1; vertices = i - 1;
} }
@ -553,20 +553,18 @@ int GPUState::PH_Move(GPUReg* r, int size)
Flush(); Flush();
CPoint src, dst; int sx = r[1].XY.X;
int sy = r[1].XY.Y;
src.x = r[1].XY.X; int dx = r[2].XY.X;
src.y = r[1].XY.Y; int dy = r[2].XY.Y;
dst.x = r[2].XY.X;
dst.y = r[2].XY.Y;
int w = r[3].XY.X; int w = r[3].XY.X;
int h = r[3].XY.Y; int h = r[3].XY.Y;
m_mem.MoveRect(src, dst, w, h); m_mem.MoveRect(sx, sy, dx, dy, w, h);
Invalidate(CRect(dst, CSize(w, h))); Invalidate(GSVector4i(dx, dy, dx + w, dy + h));
// Dump("m"); // Dump("m");
@ -586,14 +584,14 @@ int GPUState::PH_Write(GPUReg* r, int size)
Flush(); Flush();
CRect r2; GSVector4i r2;
r2.left = r[1].XY.X; r2.left = r[1].XY.X;
r2.top = r[1].XY.Y; r2.top = r[1].XY.Y;
r2.right = r2.left + w; r2.right = r2.left + w;
r2.bottom = r2.top + h; r2.bottom = r2.top + h;
m_mem.WriteRect(r2, (const WORD*)&r[3]); m_mem.WriteRect(r2, (const uint16*)&r[3]);
Invalidate(r2); Invalidate(r2);
@ -613,7 +611,7 @@ int GPUState::PH_Read(GPUReg* r, int size)
int w = r[2].XY.X; int w = r[2].XY.X;
int h = r[2].XY.Y; int h = r[2].XY.Y;
CRect r2; GSVector4i r2;
r2.left = r[1].XY.X; r2.left = r[1].XY.X;
r2.top = r[1].XY.Y; r2.top = r[1].XY.Y;
@ -624,7 +622,7 @@ int GPUState::PH_Read(GPUReg* r, int size)
m_read.cur = 0; m_read.cur = 0;
m_read.Reserve(m_read.bytes); m_read.Reserve(m_read.bytes);
m_mem.ReadRect(r2, (WORD*)m_read.buff); m_mem.ReadRect(r2, (uint16*)m_read.buff);
Dump("r"); Dump("r");
@ -693,7 +691,7 @@ GPUState::Buffer::Buffer()
{ {
bytes = 0; bytes = 0;
maxbytes = 4096; maxbytes = 4096;
buff = (BYTE*)_aligned_malloc(maxbytes, 16); buff = (uint8*)_aligned_malloc(maxbytes, 16);
cur = 0; cur = 0;
} }
@ -708,11 +706,11 @@ void GPUState::Buffer::Reserve(int size)
{ {
maxbytes = (maxbytes + size + 1023) & ~1023; maxbytes = (maxbytes + size + 1023) & ~1023;
buff = (BYTE*)_aligned_realloc(buff, maxbytes, 16); buff = (uint8*)_aligned_realloc(buff, maxbytes, 16);
} }
} }
void GPUState::Buffer::Append(const BYTE* src, int size) void GPUState::Buffer::Append(const uint8* src, int size)
{ {
Reserve(bytes + (int)size); Reserve(bytes + (int)size);

24
plugins/GSdx/GPUState.h
View File

@ -65,14 +65,14 @@ class GPUState : public GSAlignedClass<16>
public: public:
int bytes; int bytes;
int maxbytes; int maxbytes;
BYTE* buff; uint8* buff;
int cur; int cur;
public: public:
Buffer(); Buffer();
~Buffer(); ~Buffer();
void Reserve(int size); void Reserve(int size);
void Append(const BYTE* src, int size); void Append(const uint8* src, int size);
void Remove(int size); void Remove(int size);
void RemoveAll(); void RemoveAll();
}; };
@ -88,10 +88,10 @@ protected:
int s_n; int s_n;
void Dump(const string& s, UINT32 TP, const CRect& r, int inc = true) void Dump(const string& s, uint32 TP, const GSVector4i& r, int inc = true)
{ {
//if(m_perfmon.GetFrame() < 1000) //if(m_perfmon.GetFrame() < 1000)
//if((m_env.TWIN.ai32 & 0xfffff) == 0) //if((m_env.TWIN.u32 & 0xfffff) == 0)
//if(!m_env.STATUS.ME && !m_env.STATUS.MD) //if(!m_env.STATUS.ME && !m_env.STATUS.MD)
return; return;
@ -108,7 +108,7 @@ protected:
void Dump(const string& s, int inc = true) void Dump(const string& s, int inc = true)
{ {
Dump(s, 2, CRect(0, 0, 1024, 512), inc); Dump(s, 2, GSVector4i(0, 0, 1024, 512), inc);
} }
public: public:
@ -116,10 +116,10 @@ public:
GPULocalMemory m_mem; GPULocalMemory m_mem;
GPUVertex m_v; GPUVertex m_v;
GSPerfMon m_perfmon; GSPerfMon m_perfmon;
UINT32 m_status[256]; uint32 m_status[256];
public: public:
GPUState(const CSize& scale); GPUState(const GSVector2i& scale);
virtual ~GPUState(); virtual ~GPUState();
virtual void Reset(); virtual void Reset();
@ -127,13 +127,13 @@ public:
virtual void FlushPrim() = 0; virtual void FlushPrim() = 0;
virtual void ResetPrim() = 0; virtual void ResetPrim() = 0;
virtual void VertexKick() = 0; virtual void VertexKick() = 0;
virtual void Invalidate(const CRect& r); virtual void Invalidate(const GSVector4i& r);
void WriteData(const BYTE* mem, UINT32 size); void WriteData(const uint8* mem, uint32 size);
void ReadData(BYTE* mem, UINT32 size); void ReadData(uint8* mem, uint32 size);
void WriteStatus(UINT32 status); void WriteStatus(uint32 status);
UINT32 ReadStatus(); uint32 ReadStatus();
void Freeze(GPUFreezeData* data); void Freeze(GPUFreezeData* data);
void Defrost(const GPUFreezeData* data); void Defrost(const GPUFreezeData* data);

56
plugins/GSdx/GS.cpp
View File

@ -35,9 +35,9 @@
static HRESULT s_hr = E_FAIL; static HRESULT s_hr = E_FAIL;
static GSRendererBase* s_gs = NULL; static GSRendererBase* s_gs = NULL;
static void (*s_irq)() = NULL; static void (*s_irq)() = NULL;
static BYTE* s_basemem = NULL; static uint8* s_basemem = NULL;
EXPORT_C_(UINT32) PS2EgetLibType() EXPORT_C_(uint32) PS2EgetLibType()
{ {
return PS2E_LT_GS; return PS2E_LT_GS;
} }
@ -47,15 +47,15 @@ EXPORT_C_(char*) PS2EgetLibName()
return GSUtil::GetLibName(); return GSUtil::GetLibName();
} }
EXPORT_C_(UINT32) PS2EgetLibVersion2(UINT32 type) EXPORT_C_(uint32) PS2EgetLibVersion2(uint32 type)
{ {
const UINT32 revision = 0; const uint32 revision = 0;
const UINT32 build = 1; const uint32 build = 1;
return (build << 0) | (revision << 8) | (PS2E_GS_VERSION << 16) | (PLUGIN_VERSION << 24); return (build << 0) | (revision << 8) | (PS2E_GS_VERSION << 16) | (PLUGIN_VERSION << 24);
} }
EXPORT_C_(UINT32) PS2EgetCpuPlatform() EXPORT_C_(uint32) PS2EgetCpuPlatform()
{ {
#if _M_AMD64 #if _M_AMD64
return PS2E_X86_64; return PS2E_X86_64;
@ -64,7 +64,7 @@ EXPORT_C_(UINT32) PS2EgetCpuPlatform()
#endif #endif
} }
EXPORT_C GSsetBaseMem(BYTE* mem) EXPORT_C GSsetBaseMem(uint8* mem)
{ {
s_basemem = mem - 0x12000000; s_basemem = mem - 0x12000000;
} }
@ -175,37 +175,37 @@ EXPORT_C GSreset()
s_gs->Reset(); s_gs->Reset();
} }
EXPORT_C GSgifSoftReset(int mask) EXPORT_C GSgifSoftReset(uint32 mask)
{ {
s_gs->SoftReset((BYTE)mask); s_gs->SoftReset(mask);
} }
EXPORT_C GSwriteCSR(UINT32 csr) EXPORT_C GSwriteCSR(uint32 csr)
{ {
s_gs->WriteCSR(csr); s_gs->WriteCSR(csr);
} }
EXPORT_C GSreadFIFO(BYTE* mem) EXPORT_C GSreadFIFO(uint8* mem)
{ {
s_gs->ReadFIFO(mem, 1); s_gs->ReadFIFO(mem, 1);
} }
EXPORT_C GSreadFIFO2(BYTE* mem, UINT32 size) EXPORT_C GSreadFIFO2(uint8* mem, uint32 size)
{ {
s_gs->ReadFIFO(mem, size); s_gs->ReadFIFO(mem, size);
} }
EXPORT_C GSgifTransfer1(BYTE* mem, UINT32 addr) EXPORT_C GSgifTransfer1(uint8* mem, uint32 addr)
{ {
s_gs->Transfer<0>(mem + addr, (0x4000 - addr) / 16); s_gs->Transfer<0>(mem + addr, (0x4000 - addr) / 16);
} }
EXPORT_C GSgifTransfer2(BYTE* mem, UINT32 size) EXPORT_C GSgifTransfer2(uint8* mem, uint32 size)
{ {
s_gs->Transfer<1>(mem, size); s_gs->Transfer<1>(mem, size);
} }
EXPORT_C GSgifTransfer3(BYTE* mem, UINT32 size) EXPORT_C GSgifTransfer3(uint8* mem, uint32 size)
{ {
s_gs->Transfer<2>(mem, size); s_gs->Transfer<2>(mem, size);
} }
@ -215,7 +215,7 @@ EXPORT_C GSvsync(int field)
s_gs->VSync(field); s_gs->VSync(field);
} }
EXPORT_C_(UINT32) GSmakeSnapshot(char* path) EXPORT_C_(uint32) GSmakeSnapshot(char* path)
{ {
return s_gs->MakeSnapshot(string(path) + "gsdx"); return s_gs->MakeSnapshot(string(path) + "gsdx");
} }
@ -224,7 +224,7 @@ EXPORT_C GSkeyEvent(keyEvent* ev)
{ {
} }
EXPORT_C_(INT32) GSfreeze(int mode, GSFreezeData* data) EXPORT_C_(int) GSfreeze(int mode, GSFreezeData* data)
{ {
if(mode == FREEZE_SAVE) if(mode == FREEZE_SAVE)
{ {
@ -279,12 +279,12 @@ EXPORT_C GSirqCallback(void (*irq)())
s_irq = irq; s_irq = irq;
} }
EXPORT_C GSsetGameCRC(DWORD crc, int options) EXPORT_C GSsetGameCRC(uint32 crc, int options)
{ {
s_gs->SetGameCRC(crc, options); s_gs->SetGameCRC(crc, options);
} }
EXPORT_C GSgetLastTag(UINT32* tag) EXPORT_C GSgetLastTag(uint32* tag)
{ {
s_gs->GetLastTag(tag); s_gs->GetLastTag(tag);
} }
@ -309,25 +309,25 @@ EXPORT_C GSReplay(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow)
::SetPriorityClass(::GetCurrentProcess(), HIGH_PRIORITY_CLASS); ::SetPriorityClass(::GetCurrentProcess(), HIGH_PRIORITY_CLASS);
vector<BYTE> buff; vector<uint8> buff;
if(FILE* fp = fopen(lpszCmdLine, "rb")) if(FILE* fp = fopen(lpszCmdLine, "rb"))
{ {
GSinit(); GSinit();
BYTE regs[0x2000]; uint8 regs[0x2000];
GSsetBaseMem(regs); GSsetBaseMem(regs);
HWND hWnd = NULL; HWND hWnd = NULL;
GSopen(&hWnd, "", true, renderer); GSopen(&hWnd, "", true, renderer);
DWORD crc; uint32 crc;
fread(&crc, 4, 1, fp); fread(&crc, 4, 1, fp);
GSsetGameCRC(crc, 0); GSsetGameCRC(crc, 0);
GSFreezeData fd; GSFreezeData fd;
fread(&fd.size, 4, 1, fp); fread(&fd.size, 4, 1, fp);
fd.data = new BYTE[fd.size]; fd.data = new uint8[fd.size];
fread(fd.data, fd.size, 1, fp); fread(fd.data, fd.size, 1, fp);
GSfreeze(FREEZE_LOAD, &fd); GSfreeze(FREEZE_LOAD, &fd);
delete [] fd.data; delete [] fd.data;
@ -425,9 +425,9 @@ EXPORT_C GSBenchmark(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow
{PSM_PSMZ16S, "16ZS"}, {PSM_PSMZ16S, "16ZS"},
}; };
BYTE* ptr = (BYTE*)_aligned_malloc(1024 * 1024 * 4, 16); uint8* ptr = (uint8*)_aligned_malloc(1024 * 1024 * 4, 16);
for(int i = 0; i < 1024 * 1024 * 4; i++) ptr[i] = (BYTE)i; for(int i = 0; i < 1024 * 1024 * 4; i++) ptr[i] = (uint8)i;
// //
@ -470,7 +470,7 @@ EXPORT_C GSBenchmark(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow
TRXREG.RRW = w; TRXREG.RRW = w;
TRXREG.RRH = h; TRXREG.RRH = h;
CRect r(0, 0, w, h); GSVector4i r(0, 0, w, h);
GIFRegTEX0 TEX0; GIFRegTEX0 TEX0;
@ -560,9 +560,9 @@ EXPORT_C GSBenchmark(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow
{ {
GSLocalMemory mem; GSLocalMemory mem;
BYTE* ptr = (BYTE*)_aligned_malloc(1024 * 1024 * 4, 16); uint8* ptr = (uint8*)_aligned_malloc(1024 * 1024 * 4, 16);
for(int i = 0; i < 1024 * 1024 * 4; i++) ptr[i] = (BYTE)i; for(int i = 0; i < 1024 * 1024 * 4; i++) ptr[i] = (uint8)i;
const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[PSM_PSMCT32]; const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[PSM_PSMCT32];

962
plugins/GSdx/GS.h
View File

File diff suppressed because it is too large Load Diff

806
plugins/GSdx/GSBlock.h
View File

File diff suppressed because it is too large Load Diff

74
plugins/GSdx/GSCapture.cpp
View File

@ -46,24 +46,24 @@ class __declspec(uuid("F8BB6F4F-0965-4ED4-BA74-C6A01E6E6C77"))
#endif #endif
GSSource : public CBaseFilter, private CCritSec, public IGSSource GSSource : public CBaseFilter, private CCritSec, public IGSSource
{ {
CSize m_size; GSVector2i m_size;
REFERENCE_TIME m_atpf; REFERENCE_TIME m_atpf;
REFERENCE_TIME m_now; REFERENCE_TIME m_now;
STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv) STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void** ppv)
{ {
return return
QI(IGSSource) riid == __uuidof(IGSSource) ? GetInterface((IGSSource*)this, ppv) :
__super::NonDelegatingQueryInterface(riid, ppv); __super::NonDelegatingQueryInterface(riid, ppv);
} }
class GSSourceOutputPin : public CBaseOutputPin class GSSourceOutputPin : public CBaseOutputPin
{ {
CSize m_size; GSVector2i m_size;
vector<CMediaType> m_mts; vector<CMediaType> m_mts;
public: public:
GSSourceOutputPin(CSize size, REFERENCE_TIME atpf, CBaseFilter* pFilter, CCritSec* pLock, HRESULT& hr) GSSourceOutputPin(const GSVector2i& size, REFERENCE_TIME atpf, CBaseFilter* pFilter, CCritSec* pLock, HRESULT& hr)
: CBaseOutputPin("GSSourceOutputPin", pFilter, pLock, &hr, L"Output") : CBaseOutputPin("GSSourceOutputPin", pFilter, pLock, &hr, L"Output")
, m_size(size) , m_size(size)
{ {
@ -75,36 +75,32 @@ GSSource : public CBaseFilter, private CCritSec, public IGSSource
memset(&vih, 0, sizeof(vih)); memset(&vih, 0, sizeof(vih));
vih.AvgTimePerFrame = atpf; vih.AvgTimePerFrame = atpf;
vih.bmiHeader.biSize = sizeof(vih.bmiHeader); vih.bmiHeader.biSize = sizeof(vih.bmiHeader);
vih.bmiHeader.biWidth = m_size.cx; vih.bmiHeader.biWidth = m_size.x;
vih.bmiHeader.biHeight = m_size.cy; vih.bmiHeader.biHeight = m_size.y;
#if _M_SSE >= 0x200
// YUY2 // YUY2
mt.subtype = MEDIASUBTYPE_YUY2; mt.subtype = MEDIASUBTYPE_YUY2;
mt.lSampleSize = m_size.cx * m_size.cy * 2; mt.lSampleSize = m_size.x * m_size.y * 2;
vih.bmiHeader.biCompression = '2YUY'; vih.bmiHeader.biCompression = '2YUY';
vih.bmiHeader.biPlanes = 1; vih.bmiHeader.biPlanes = 1;
vih.bmiHeader.biBitCount = 16; vih.bmiHeader.biBitCount = 16;
vih.bmiHeader.biSizeImage = m_size.cx * m_size.cy * 2; vih.bmiHeader.biSizeImage = m_size.x * m_size.y * 2;
mt.SetFormat((BYTE*)&vih, sizeof(vih)); mt.SetFormat((uint8*)&vih, sizeof(vih));
m_mts.push_back(mt); m_mts.push_back(mt);
#endif
// RGB32 // RGB32
mt.subtype = MEDIASUBTYPE_RGB32; mt.subtype = MEDIASUBTYPE_RGB32;
mt.lSampleSize = m_size.cx * m_size.cy * 4; mt.lSampleSize = m_size.x * m_size.y * 4;
vih.bmiHeader.biCompression = BI_RGB; vih.bmiHeader.biCompression = BI_RGB;
vih.bmiHeader.biPlanes = 1; vih.bmiHeader.biPlanes = 1;
vih.bmiHeader.biBitCount = 32; vih.bmiHeader.biBitCount = 32;
vih.bmiHeader.biSizeImage = m_size.cx * m_size.cy * 4; vih.bmiHeader.biSizeImage = m_size.x * m_size.y * 4;
mt.SetFormat((BYTE*)&vih, sizeof(vih)); mt.SetFormat((uint8*)&vih, sizeof(vih));
m_mts.push_back(mt); m_mts.push_back(mt);
} }
@ -231,17 +227,15 @@ public:
const CMediaType& mt = m_output->CurrentMediaType(); const CMediaType& mt = m_output->CurrentMediaType();
BYTE* src = (BYTE*)bits; uint8* src = (uint8*)bits;
uint8* dst = NULL;
BYTE* dst = NULL;
sample->GetPointer(&dst); sample->GetPointer(&dst);
int w = m_size.cx; int w = m_size.x;
int h = m_size.cy; int h = m_size.y;
int srcpitch = pitch; int srcpitch = pitch;
#if _M_SSE >= 0x200
if(mt.subtype == MEDIASUBTYPE_YUY2) if(mt.subtype == MEDIASUBTYPE_YUY2)
{ {
int dstpitch = ((VIDEOINFOHEADER*)mt.Format())->bmiHeader.biWidth * 2; int dstpitch = ((VIDEOINFOHEADER*)mt.Format())->bmiHeader.biWidth * 2;
@ -255,8 +249,8 @@ public:
{ {
for(int j = 0; j < h; j++, dst += dstpitch, src += srcpitch) for(int j = 0; j < h; j++, dst += dstpitch, src += srcpitch)
{ {
DWORD* s = (DWORD*)src; uint32* s = (uint32*)src;
WORD* d = (WORD*)dst; uint16* d = (uint16*)dst;
for(int i = 0; i < w; i += 2) for(int i = 0; i < w; i += 2)
{ {
@ -269,7 +263,7 @@ public:
GSVector4 c = lo.hadd(hi) + offset; GSVector4 c = lo.hadd(hi) + offset;
*((DWORD*)&d[i]) = GSVector4i(c).rgba32(); *((uint32*)&d[i]) = GSVector4i(c).rgba32();
} }
} }
} }
@ -277,8 +271,8 @@ public:
{ {
for(int j = 0; j < h; j++, dst += dstpitch, src += srcpitch) for(int j = 0; j < h; j++, dst += dstpitch, src += srcpitch)
{ {
DWORD* s = (DWORD*)src; uint32* s = (uint32*)src;
WORD* d = (WORD*)dst; uint16* d = (uint16*)dst;
for(int i = 0; i < w; i += 2) for(int i = 0; i < w; i += 2)
{ {
@ -291,16 +285,12 @@ public:
GSVector4 c = lo.hadd(hi) + offset; GSVector4 c = lo.hadd(hi) + offset;
*((DWORD*)&d[i]) = GSVector4i(c).rgba32(); *((uint32*)&d[i]) = GSVector4i(c).rgba32();
} }
} }
} }
} }
else else if(mt.subtype == MEDIASUBTYPE_RGB32)
#endif
if(mt.subtype == MEDIASUBTYPE_RGB32)
{ {
int dstpitch = ((VIDEOINFOHEADER*)mt.Format())->bmiHeader.biWidth * 4; int dstpitch = ((VIDEOINFOHEADER*)mt.Format())->bmiHeader.biWidth * 4;
@ -323,7 +313,7 @@ public:
d[i] = s[i].shuffle8(mask); d[i] = s[i].shuffle8(mask);
} }
#elif _M_SSE >= 0x200 #else
GSVector4i* s = (GSVector4i*)src; GSVector4i* s = (GSVector4i*)src;
GSVector4i* d = (GSVector4i*)dst; GSVector4i* d = (GSVector4i*)dst;
@ -333,16 +323,6 @@ public:
d[i] = ((s[i] & 0x00ff0000) >> 16) | ((s[i] & 0x000000ff) << 16) | (s[i] & 0x0000ff00); d[i] = ((s[i] & 0x00ff0000) >> 16) | ((s[i] & 0x000000ff) << 16) | (s[i] & 0x0000ff00);
} }
#else
DWORD* s = (DWORD*)src;
DWORD* d = (DWORD*)dst;
for(int i = 0; i < w; i++)
{
d[i] = ((s[i] & 0x00ff0000) >> 16) | ((s[i] & 0x000000ff) << 16) | (s[i] & 0x0000ff00);
}
#endif #endif
} }
else else
@ -429,8 +409,8 @@ bool GSCapture::BeginCapture(int fps)
if(IDOK != dlg.DoModal()) return false; if(IDOK != dlg.DoModal()) return false;
m_size.cx = (dlg.m_width + 7) & ~7; m_size.x = (dlg.m_width + 7) & ~7;
m_size.cy = (dlg.m_height + 7) & ~7; m_size.y = (dlg.m_height + 7) & ~7;
// //
@ -447,7 +427,7 @@ bool GSCapture::BeginCapture(int fps)
return false; return false;
} }
m_src = new GSSource(m_size.cx, m_size.cy, fps, NULL, hr); m_src = new GSSource(m_size.x, m_size.y, fps, NULL, hr);
if(FAILED(hr = m_graph->AddFilter(m_src, L"Source")) if(FAILED(hr = m_graph->AddFilter(m_src, L"Source"))
|| FAILED(hr = m_graph->AddFilter(dlg.m_enc, L"Encoder"))) || FAILED(hr = m_graph->AddFilter(dlg.m_enc, L"Encoder")))

5
plugins/GSdx/GSCapture.h
View File

@ -22,11 +22,12 @@
#pragma once #pragma once
#include "GSCaptureDlg.h" #include "GSCaptureDlg.h"
#include "GSVector.h"
class GSCapture : protected CCritSec class GSCapture : protected CCritSec
{ {
bool m_capturing; bool m_capturing;
CSize m_size; GSVector2i m_size;
CComPtr<IGraphBuilder> m_graph; CComPtr<IGraphBuilder> m_graph;
CComPtr<IBaseFilter> m_src; CComPtr<IBaseFilter> m_src;
@ -39,5 +40,5 @@ public:
bool EndCapture(); bool EndCapture();
bool IsCapturing() {return m_capturing;} bool IsCapturing() {return m_capturing;}
CSize GetSize() {return m_size;} GSVector2i GetSize() {return m_size;}
}; };

283
plugins/GSdx/GSClut.cpp
View File

@ -26,11 +26,11 @@
GSClut::GSClut(const GSLocalMemory* mem) GSClut::GSClut(const GSLocalMemory* mem)
: m_mem(mem) : m_mem(mem)
{ {
BYTE* p = (BYTE*)VirtualAlloc(NULL, 2 * 4096, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); uint8* p = (uint8*)VirtualAlloc(NULL, 2 * 4096, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
m_clut = (WORD*)&p[0]; // 1k + 1k for buffer overruns (sfex: PSM == PSM_PSMT8, CPSM == PSM_PSMCT32, CSA != 0) m_clut = (uint16*)&p[0]; // 1k + 1k for buffer overruns (sfex: PSM == PSM_PSMT8, CPSM == PSM_PSMCT32, CSA != 0)
m_buff32 = (DWORD*)&p[2048]; // 1k m_buff32 = (uint32*)&p[2048]; // 1k
m_buff64 = (UINT64*)&p[4096]; // 2k m_buff64 = (uint64*)&p[4096]; // 2k
m_write.dirty = true; m_write.dirty = true;
m_read.dirty = true; m_read.dirty = true;
@ -128,7 +128,7 @@ void GSClut::WriteCLUT32_I8_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TE
{ {
ASSERT(TEX0.CSA == 0); ASSERT(TEX0.CSA == 0);
WriteCLUT_T32_I8_CSM1((DWORD*)m_mem->BlockPtr32(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4)); WriteCLUT_T32_I8_CSM1((uint32*)m_mem->BlockPtr32(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4));
} }
void GSClut::WriteCLUT32_I4_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT) void GSClut::WriteCLUT32_I4_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
@ -137,72 +137,72 @@ void GSClut::WriteCLUT32_I4_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TE
GSVector4i dummy; // this just forces stack alignment and enables inlining the next call GSVector4i dummy; // this just forces stack alignment and enables inlining the next call
WriteCLUT_T32_I4_CSM1((DWORD*)m_mem->BlockPtr32(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4)); WriteCLUT_T32_I4_CSM1((uint32*)m_mem->BlockPtr32(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4));
} }
void GSClut::WriteCLUT16_I8_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT) void GSClut::WriteCLUT16_I8_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
{ {
ASSERT(TEX0.CSA < 16); ASSERT(TEX0.CSA < 16);
WriteCLUT_T16_I8_CSM1((WORD*)m_mem->BlockPtr16(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4)); WriteCLUT_T16_I8_CSM1((uint16*)m_mem->BlockPtr16(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4));
} }
void GSClut::WriteCLUT16_I4_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT) void GSClut::WriteCLUT16_I4_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
{ {
ASSERT(TEX0.CSA < 32); ASSERT(TEX0.CSA < 32);
WriteCLUT_T16_I4_CSM1((WORD*)m_mem->BlockPtr16(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4)); WriteCLUT_T16_I4_CSM1((uint16*)m_mem->BlockPtr16(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4));
} }
void GSClut::WriteCLUT16S_I8_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT) void GSClut::WriteCLUT16S_I8_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
{ {
WriteCLUT_T16_I8_CSM1((WORD*)m_mem->BlockPtr16S(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4)); WriteCLUT_T16_I8_CSM1((uint16*)m_mem->BlockPtr16S(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4));
} }
void GSClut::WriteCLUT16S_I4_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT) void GSClut::WriteCLUT16S_I4_CSM1(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
{ {
WriteCLUT_T16_I4_CSM1((WORD*)m_mem->BlockPtr16S(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4)); WriteCLUT_T16_I4_CSM1((uint16*)m_mem->BlockPtr16S(0, 0, TEX0.CBP, 1), m_clut + (TEX0.CSA << 4));
} }
template<int n> void GSClut::WriteCLUT32_CSM2(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT) template<int n> void GSClut::WriteCLUT32_CSM2(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
{ {
WORD* RESTRICT clut = m_clut + (TEX0.CSA << 4); uint16* RESTRICT clut = m_clut + (TEX0.CSA << 4);
DWORD base = m_mem->PixelAddress32(0, TEXCLUT.COV, TEX0.CBP, TEXCLUT.CBW); uint32 base = m_mem->PixelAddress32(0, TEXCLUT.COV, TEX0.CBP, TEXCLUT.CBW);
int* offset = &m_mem->rowOffset32[TEXCLUT.COU << 4]; int* offset = &m_mem->rowOffset32[TEXCLUT.COU << 4];
for(int i = 0; i < n; i++) for(int i = 0; i < n; i++)
{ {
DWORD c = m_mem->ReadPixel32(base + offset[i]); uint32 c = m_mem->ReadPixel32(base + offset[i]);
clut[i] = (WORD)(c & 0xffff); clut[i] = (uint16)(c & 0xffff);
clut[i + 256] = (WORD)(c >> 16); clut[i + 256] = (uint16)(c >> 16);
} }
} }
template<int n> void GSClut::WriteCLUT16_CSM2(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT) template<int n> void GSClut::WriteCLUT16_CSM2(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
{ {
WORD* RESTRICT clut = m_clut + (TEX0.CSA << 4); uint16* RESTRICT clut = m_clut + (TEX0.CSA << 4);
DWORD base = m_mem->PixelAddress16(0, TEXCLUT.COV, TEX0.CBP, TEXCLUT.CBW); uint32 base = m_mem->PixelAddress16(0, TEXCLUT.COV, TEX0.CBP, TEXCLUT.CBW);
int* offset = &m_mem->rowOffset16[TEXCLUT.COU << 4]; int* offset = &m_mem->rowOffset16[TEXCLUT.COU << 4];
for(int i = 0; i < n; i++) for(int i = 0; i < n; i++)
{ {
clut[i] = (WORD)m_mem->ReadPixel16(base + offset[i]); clut[i] = (uint16)m_mem->ReadPixel16(base + offset[i]);
} }
} }
template<int n> void GSClut::WriteCLUT16S_CSM2(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT) template<int n> void GSClut::WriteCLUT16S_CSM2(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
{ {
WORD* RESTRICT clut = m_clut + (TEX0.CSA << 4); uint16* RESTRICT clut = m_clut + (TEX0.CSA << 4);
DWORD base = m_mem->PixelAddress16S(0, TEXCLUT.COV, TEX0.CBP, TEXCLUT.CBW); uint32 base = m_mem->PixelAddress16S(0, TEXCLUT.COV, TEX0.CBP, TEXCLUT.CBW);
int* offset = &m_mem->rowOffset16S[TEXCLUT.COU << 4]; int* offset = &m_mem->rowOffset16S[TEXCLUT.COU << 4];
for(int i = 0; i < n; i++) for(int i = 0; i < n; i++)
{ {
clut[i] = (WORD)m_mem->ReadPixel16(base + offset[i]); clut[i] = (uint16)m_mem->ReadPixel16(base + offset[i]);
} }
} }
@ -213,7 +213,7 @@ void GSClut::Read(const GIFRegTEX0& TEX0)
m_read.TEX0 = TEX0; m_read.TEX0 = TEX0;
m_read.dirty = false; m_read.dirty = false;
WORD* clut = m_clut + (TEX0.CSA << 4); uint16* clut = m_clut + (TEX0.CSA << 4);
if(TEX0.CPSM == PSM_PSMCT32 || TEX0.CPSM == PSM_PSMCT24) if(TEX0.CPSM == PSM_PSMCT32 || TEX0.CPSM == PSM_PSMCT24)
{ {
@ -257,7 +257,7 @@ void GSClut::Read32(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA)
m_read.dirty = false; m_read.dirty = false;
m_read.adirty = true; m_read.adirty = true;
WORD* clut = m_clut + (TEX0.CSA << 4); uint16* clut = m_clut + (TEX0.CSA << 4);
if(TEX0.CPSM == PSM_PSMCT32 || TEX0.CPSM == PSM_PSMCT24) if(TEX0.CPSM == PSM_PSMCT32 || TEX0.CPSM == PSM_PSMCT24)
{ {
@ -272,7 +272,7 @@ void GSClut::Read32(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA)
case PSM_PSMT4HH: case PSM_PSMT4HH:
// TODO: merge these functions // TODO: merge these functions
ReadCLUT_T32_I4(clut, m_buff32); ReadCLUT_T32_I4(clut, m_buff32);
ExpandCLUT64_T32_I8(m_buff32, (UINT64*)m_buff64); // sw renderer does not need m_buff64 anymore ExpandCLUT64_T32_I8(m_buff32, (uint64*)m_buff64); // sw renderer does not need m_buff64 anymore
break; break;
} }
} }
@ -289,7 +289,7 @@ void GSClut::Read32(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA)
case PSM_PSMT4HH: case PSM_PSMT4HH:
// TODO: merge these functions // TODO: merge these functions
Expand16(clut, m_buff32, 16, TEXA); Expand16(clut, m_buff32, 16, TEXA);
ExpandCLUT64_T32_I8(m_buff32, (UINT64*)m_buff64); // sw renderer does not need m_buff64 anymore ExpandCLUT64_T32_I8(m_buff32, (uint64*)m_buff64); // sw renderer does not need m_buff64 anymore
break; break;
} }
} }
@ -306,9 +306,9 @@ void GSClut::GetAlphaMinMax32(int& amin, int& amax)
{ {
m_read.adirty = false; m_read.adirty = false;
// DWORD bpp = GSLocalMemory::m_psm[m_read.TEX0.PSM].trbpp; // uint32 bpp = GSLocalMemory::m_psm[m_read.TEX0.PSM].trbpp;
DWORD cbpp = GSLocalMemory::m_psm[m_read.TEX0.CPSM].trbpp; uint32 cbpp = GSLocalMemory::m_psm[m_read.TEX0.CPSM].trbpp;
DWORD pal = GSLocalMemory::m_psm[m_read.TEX0.PSM].pal; uint32 pal = GSLocalMemory::m_psm[m_read.TEX0.PSM].pal;
if(cbpp == 24 && m_read.TEXA.AEM == 0) if(cbpp == 24 && m_read.TEXA.AEM == 0)
{ {
@ -352,10 +352,8 @@ void GSClut::GetAlphaMinMax32(int& amin, int& amax)
// //
void GSClut::WriteCLUT_T32_I8_CSM1(const DWORD* RESTRICT src, WORD* RESTRICT clut) void GSClut::WriteCLUT_T32_I8_CSM1(const uint32* RESTRICT src, uint16* RESTRICT clut)
{ {
#if _M_SSE >= 0x200
for(int i = 0; i < 64; i += 16) for(int i = 0; i < 64; i += 16)
{ {
WriteCLUT_T32_I4_CSM1(&src[i + 0], &clut[i * 2 + 0]); WriteCLUT_T32_I4_CSM1(&src[i + 0], &clut[i * 2 + 0]);
@ -363,26 +361,10 @@ void GSClut::WriteCLUT_T32_I8_CSM1(const DWORD* RESTRICT src, WORD* RESTRICT clu
WriteCLUT_T32_I4_CSM1(&src[i + 128], &clut[i * 2 + 128]); WriteCLUT_T32_I4_CSM1(&src[i + 128], &clut[i * 2 + 128]);
WriteCLUT_T32_I4_CSM1(&src[i + 192], &clut[i * 2 + 144]); WriteCLUT_T32_I4_CSM1(&src[i + 192], &clut[i * 2 + 144]);
} }
#else
for(int j = 0; j < 2; j++, src += 128, clut += 128)
{
for(int i = 0; i < 128; i++)
{
DWORD c = src[clutTableT32I8[i]];
clut[i] = (WORD)(c & 0xffff);
clut[i + 256] = (WORD)(c >> 16);
}
}
#endif
} }
__forceinline void GSClut::WriteCLUT_T32_I4_CSM1(const DWORD* RESTRICT src, WORD* RESTRICT clut) __forceinline void GSClut::WriteCLUT_T32_I4_CSM1(const uint32* RESTRICT src, uint16* RESTRICT clut)
{ {
#if _M_SSE >= 0x200
GSVector4i* s = (GSVector4i*)src; GSVector4i* s = (GSVector4i*)src;
GSVector4i* d = (GSVector4i*)clut; GSVector4i* d = (GSVector4i*)clut;
@ -400,23 +382,10 @@ __forceinline void GSClut::WriteCLUT_T32_I4_CSM1(const DWORD* RESTRICT src, WORD
d[1] = v1; d[1] = v1;
d[32] = v2; d[32] = v2;
d[33] = v3; d[33] = v3;
#else
for(int i = 0; i < 16; i++)
{
DWORD c = src[clutTableT32I4[i]];
clut[i] = (WORD)(c & 0xffff);
clut[i + 256] = (WORD)(c >> 16);
}
#endif
} }
void GSClut::WriteCLUT_T16_I8_CSM1(const WORD* RESTRICT src, WORD* RESTRICT clut) void GSClut::WriteCLUT_T16_I8_CSM1(const uint16* RESTRICT src, uint16* RESTRICT clut)
{ {
#if _M_SSE >= 0x200
GSVector4i* s = (GSVector4i*)src; GSVector4i* s = (GSVector4i*)src;
GSVector4i* d = (GSVector4i*)clut; GSVector4i* d = (GSVector4i*)clut;
@ -436,21 +405,9 @@ void GSClut::WriteCLUT_T16_I8_CSM1(const WORD* RESTRICT src, WORD* RESTRICT clut
d[i + 2] = v1; d[i + 2] = v1;
d[i + 3] = v3; d[i + 3] = v3;
} }
#else
for(int j = 0; j < 8; j++, src += 32, clut += 32)
{
for(int i = 0; i < 32; i++)
{
clut[i] = src[clutTableT16I8[i]];
}
}
#endif
} }
__forceinline void GSClut::WriteCLUT_T16_I4_CSM1(const WORD* RESTRICT src, WORD* RESTRICT clut) __forceinline void GSClut::WriteCLUT_T16_I4_CSM1(const uint16* RESTRICT src, uint16* RESTRICT clut)
{ {
for(int i = 0; i < 16; i++) for(int i = 0; i < 16; i++)
{ {
@ -458,29 +415,16 @@ __forceinline void GSClut::WriteCLUT_T16_I4_CSM1(const WORD* RESTRICT src, WORD*
} }
} }
void GSClut::ReadCLUT_T32_I8(const WORD* RESTRICT clut, DWORD* RESTRICT dst) void GSClut::ReadCLUT_T32_I8(const uint16* RESTRICT clut, uint32* RESTRICT dst)
{ {
#if _M_SSE >= 0x200
for(int i = 0; i < 256; i += 16) for(int i = 0; i < 256; i += 16)
{ {
ReadCLUT_T32_I4(&clut[i], &dst[i]); ReadCLUT_T32_I4(&clut[i], &dst[i]);
} }
#else
for(int i = 0; i < 256; i++)
{
dst[i] = ((DWORD)clut[i + 256] << 16) | clut[i];
}
#endif
} }
__forceinline void GSClut::ReadCLUT_T32_I4(const WORD* RESTRICT clut, DWORD* RESTRICT dst) __forceinline void GSClut::ReadCLUT_T32_I4(const uint16* RESTRICT clut, uint32* RESTRICT dst)
{ {
#if _M_SSE >= 0x200
GSVector4i* s = (GSVector4i*)clut; GSVector4i* s = (GSVector4i*)clut;
GSVector4i* d = (GSVector4i*)dst; GSVector4i* d = (GSVector4i*)dst;
@ -495,21 +439,10 @@ __forceinline void GSClut::ReadCLUT_T32_I4(const WORD* RESTRICT clut, DWORD* RES
d[1] = v1; d[1] = v1;
d[2] = v2; d[2] = v2;
d[3] = v3; d[3] = v3;
#else
for(int i = 0; i < 16; i++)
{
dst[i] = ((DWORD)clut[i + 256] << 16) | clut[i];
}
#endif
} }
__forceinline void GSClut::ReadCLUT_T32_I4(const WORD* RESTRICT clut, DWORD* RESTRICT dst32, UINT64* RESTRICT dst64) __forceinline void GSClut::ReadCLUT_T32_I4(const uint16* RESTRICT clut, uint32* RESTRICT dst32, uint64* RESTRICT dst64)
{ {
#if _M_SSE >= 0x200
GSVector4i* s = (GSVector4i*)clut; GSVector4i* s = (GSVector4i*)clut;
GSVector4i* d32 = (GSVector4i*)dst32; GSVector4i* d32 = (GSVector4i*)dst32;
GSVector4i* d64 = (GSVector4i*)dst64; GSVector4i* d64 = (GSVector4i*)dst64;
@ -530,53 +463,18 @@ __forceinline void GSClut::ReadCLUT_T32_I4(const WORD* RESTRICT clut, DWORD* RES
ExpandCLUT64_T32(s1, s0, s1, s2, s3, &d64[32]); ExpandCLUT64_T32(s1, s0, s1, s2, s3, &d64[32]);
ExpandCLUT64_T32(s2, s0, s1, s2, s3, &d64[64]); ExpandCLUT64_T32(s2, s0, s1, s2, s3, &d64[64]);
ExpandCLUT64_T32(s3, s0, s1, s2, s3, &d64[96]); ExpandCLUT64_T32(s3, s0, s1, s2, s3, &d64[96]);
#else
for(int i = 0; i < 16; i++)
{
dst[i] = ((DWORD)clut[i + 256] << 16) | clut[i];
}
DWORD* d = (DWORD*)dst64;
for(int j = 0; j < 16; j++, d += 32)
{
DWORD hi = dst32[j];
for(int i = 0; i < 16; i++)
{
d[i * 2 + 0] = dst32[i];
d[i * 2 + 1] = hi;
}
}
#endif
} }
void GSClut::ReadCLUT_T16_I8(const WORD* RESTRICT clut, DWORD* RESTRICT dst) void GSClut::ReadCLUT_T16_I8(const uint16* RESTRICT clut, uint32* RESTRICT dst)
{ {
#if _M_SSE >= 0x200
for(int i = 0; i < 256; i += 16) for(int i = 0; i < 256; i += 16)
{ {
ReadCLUT_T16_I4(&clut[i], &dst[i]); ReadCLUT_T16_I4(&clut[i], &dst[i]);
} }
#else
for(int i = 0; i < 256; i++)
{
dst[i] = (DWORD)clut[i];
}
#endif
} }
__forceinline void GSClut::ReadCLUT_T16_I4(const WORD* RESTRICT clut, DWORD* RESTRICT dst) __forceinline void GSClut::ReadCLUT_T16_I4(const uint16* RESTRICT clut, uint32* RESTRICT dst)
{ {
#if _M_SSE >= 0x200
GSVector4i* s = (GSVector4i*)clut; GSVector4i* s = (GSVector4i*)clut;
GSVector4i* d = (GSVector4i*)dst; GSVector4i* d = (GSVector4i*)dst;
@ -587,21 +485,10 @@ __forceinline void GSClut::ReadCLUT_T16_I4(const WORD* RESTRICT clut, DWORD* RES
d[1] = v0.uph16(); d[1] = v0.uph16();
d[2] = v1.upl16(); d[2] = v1.upl16();
d[3] = v1.uph16(); d[3] = v1.uph16();
#else
for(int i = 0; i < 16; i++)
{
dst[i] = (DWORD)clut[i];
}
#endif
} }
__forceinline void GSClut::ReadCLUT_T16_I4(const WORD* RESTRICT clut, DWORD* RESTRICT dst32, UINT64* RESTRICT dst64) __forceinline void GSClut::ReadCLUT_T16_I4(const uint16* RESTRICT clut, uint32* RESTRICT dst32, uint64* RESTRICT dst64)
{ {
#if _M_SSE >= 0x200
GSVector4i* s = (GSVector4i*)clut; GSVector4i* s = (GSVector4i*)clut;
GSVector4i* d32 = (GSVector4i*)dst32; GSVector4i* d32 = (GSVector4i*)dst32;
GSVector4i* d64 = (GSVector4i*)dst64; GSVector4i* d64 = (GSVector4i*)dst64;
@ -623,33 +510,10 @@ __forceinline void GSClut::ReadCLUT_T16_I4(const WORD* RESTRICT clut, DWORD* RES
ExpandCLUT64_T16(s1, s0, s1, s2, s3, &d64[32]); ExpandCLUT64_T16(s1, s0, s1, s2, s3, &d64[32]);
ExpandCLUT64_T16(s2, s0, s1, s2, s3, &d64[64]); ExpandCLUT64_T16(s2, s0, s1, s2, s3, &d64[64]);
ExpandCLUT64_T16(s3, s0, s1, s2, s3, &d64[96]); ExpandCLUT64_T16(s3, s0, s1, s2, s3, &d64[96]);
#else
for(int i = 0; i < 16; i++)
{
dst32[i] = (DWORD)clut[i];
}
DWORD* d = (DWORD*)dst64;
for(int j = 0; j < 16; j++, d += 32)
{
DWORD hi = dst32[j] << 16;
for(int i = 0; i < 16; i++)
{
d[i * 2 + 0] = hi | (dst32[i] & 0xffff);
}
}
#endif
} }
void GSClut::ExpandCLUT64_T32_I8(const DWORD* RESTRICT src, UINT64* RESTRICT dst) void GSClut::ExpandCLUT64_T32_I8(const uint32* RESTRICT src, uint64* RESTRICT dst)
{ {
#if _M_SSE >= 0x200
GSVector4i* s = (GSVector4i*)src; GSVector4i* s = (GSVector4i*)src;
GSVector4i* d = (GSVector4i*)dst; GSVector4i* d = (GSVector4i*)dst;
@ -662,23 +526,6 @@ void GSClut::ExpandCLUT64_T32_I8(const DWORD* RESTRICT src, UINT64* RESTRICT dst
ExpandCLUT64_T32(s1, s0, s1, s2, s3, &d[32]); ExpandCLUT64_T32(s1, s0, s1, s2, s3, &d[32]);
ExpandCLUT64_T32(s2, s0, s1, s2, s3, &d[64]); ExpandCLUT64_T32(s2, s0, s1, s2, s3, &d[64]);
ExpandCLUT64_T32(s3, s0, s1, s2, s3, &d[96]); ExpandCLUT64_T32(s3, s0, s1, s2, s3, &d[96]);
#else
DWORD* d = (DWORD*)dst;
for(int j = 0; j < 16; j++, d += 32)
{
DWORD hi = src[j];
for(int i = 0; i < 16; i++)
{
d[i * 2 + 0] = src[i];
d[i * 2 + 1] = hi;
}
}
#endif
} }
__forceinline void GSClut::ExpandCLUT64_T32(const GSVector4i& hi, const GSVector4i& lo0, const GSVector4i& lo1, const GSVector4i& lo2, const GSVector4i& lo3, GSVector4i* dst) __forceinline void GSClut::ExpandCLUT64_T32(const GSVector4i& hi, const GSVector4i& lo0, const GSVector4i& lo1, const GSVector4i& lo2, const GSVector4i& lo3, GSVector4i* dst)
@ -707,10 +554,8 @@ __forceinline void GSClut::ExpandCLUT64_T32(const GSVector4i& hi, const GSVector
dst[1] = lo.uph32(hi); dst[1] = lo.uph32(hi);
} }
void GSClut::ExpandCLUT64_T16_I8(const DWORD* RESTRICT src, UINT64* RESTRICT dst) void GSClut::ExpandCLUT64_T16_I8(const uint32* RESTRICT src, uint64* RESTRICT dst)
{ {
#if _M_SSE >= 0x200
GSVector4i* s = (GSVector4i*)src; GSVector4i* s = (GSVector4i*)src;
GSVector4i* d = (GSVector4i*)dst; GSVector4i* d = (GSVector4i*)dst;
@ -723,22 +568,6 @@ void GSClut::ExpandCLUT64_T16_I8(const DWORD* RESTRICT src, UINT64* RESTRICT dst
ExpandCLUT64_T16(s1, s0, s1, s2, s3, &d[32]); ExpandCLUT64_T16(s1, s0, s1, s2, s3, &d[32]);
ExpandCLUT64_T16(s2, s0, s1, s2, s3, &d[64]); ExpandCLUT64_T16(s2, s0, s1, s2, s3, &d[64]);
ExpandCLUT64_T16(s3, s0, s1, s2, s3, &d[96]); ExpandCLUT64_T16(s3, s0, s1, s2, s3, &d[96]);
#else
DWORD* d = (DWORD*)dst;
for(int j = 0; j < 16; j++, d += 32)
{
DWORD hi = src[j] << 16;
for(int i = 0; i < 16; i++)
{
d[i * 2 + 0] = hi | (src[i] & 0xffff);
}
}
#endif
} }
__forceinline void GSClut::ExpandCLUT64_T16(const GSVector4i& hi, const GSVector4i& lo0, const GSVector4i& lo1, const GSVector4i& lo2, const GSVector4i& lo3, GSVector4i* dst) __forceinline void GSClut::ExpandCLUT64_T16(const GSVector4i& hi, const GSVector4i& lo0, const GSVector4i& lo1, const GSVector4i& lo2, const GSVector4i& lo3, GSVector4i* dst)
@ -774,10 +603,8 @@ static const GSVector4i s_bm(0x00007c00);
static const GSVector4i s_gm(0x000003e0); static const GSVector4i s_gm(0x000003e0);
static const GSVector4i s_rm(0x0000001f); static const GSVector4i s_rm(0x0000001f);
void GSClut::Expand16(const WORD* RESTRICT src, DWORD* RESTRICT dst, int w, const GIFRegTEXA& TEXA) void GSClut::Expand16(const uint16* RESTRICT src, uint32* RESTRICT dst, int w, const GIFRegTEXA& TEXA)
{ {
#if _M_SSE >= 0x200
ASSERT((w & 7) == 0); ASSERT((w & 7) == 0);
const GSVector4i rm = s_rm; const GSVector4i rm = s_rm;
@ -827,43 +654,21 @@ void GSClut::Expand16(const WORD* RESTRICT src, DWORD* RESTRICT dst, int w, cons
d[i * 2 + 1] = ((ch & rm) << 3) | ((ch & gm) << 6) | ((ch & bm) << 9) | TA0.blend8(TA1, ch.sra16(15)).andnot(ch == GSVector4i::zero()); d[i * 2 + 1] = ((ch & rm) << 3) | ((ch & gm) << 6) | ((ch & bm) << 9) | TA0.blend8(TA1, ch.sra16(15)).andnot(ch == GSVector4i::zero());
} }
} }
#else
DWORD TA0 = (DWORD)TEXA.TA0 << 24;
DWORD TA1 = (DWORD)TEXA.TA1 << 24;
if(!TEXA.AEM)
{
for(int i = 0; i < w; i++)
{
dst[i] = ((src[i] & 0x8000) ? TA1 : TA0) | ((src[i] & 0x7c00) << 9) | ((src[i] & 0x03e0) << 6) | ((src[i] & 0x001f) << 3);
}
}
else
{
for(int i = 0; i < w; i++)
{
dst[i] = ((src[i] & 0x8000) ? TA1 : src[i] ? TA0 : 0) | ((src[i] & 0x7c00) << 9) | ((src[i] & 0x03e0) << 6) | ((src[i] & 0x001f) << 3);
}
}
#endif
} }
// //
bool GSClut::WriteState::IsDirty(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT) bool GSClut::WriteState::IsDirty(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT)
{ {
return dirty || !(GSVector4i::load<true>(this) == GSVector4i::load(&TEX0, &TEXCLUT)).alltrue(); return dirty || !GSVector4i::load<true>(this).eq(GSVector4i::load(&TEX0, &TEXCLUT));
} }
bool GSClut::ReadState::IsDirty(const GIFRegTEX0& TEX0) bool GSClut::ReadState::IsDirty(const GIFRegTEX0& TEX0)
{ {
return dirty || !(GSVector4i::load<true>(this) == GSVector4i::load(&TEX0, &this->TEXA)).alltrue(); return dirty || !GSVector4i::load<true>(this).eq(GSVector4i::load(&TEX0, &this->TEXA));
} }
bool GSClut::ReadState::IsDirty(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA) bool GSClut::ReadState::IsDirty(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA)
{ {
return dirty || !(GSVector4i::load<true>(this) == GSVector4i::load(&TEX0, &TEXA)).alltrue(); return dirty || !GSVector4i::load<true>(this).eq(GSVector4i::load(&TEX0, &TEXA));
} }

40
plugins/GSdx/GSClut.h
View File

@ -32,10 +32,10 @@ __declspec(align(16)) class GSClut : public GSAlignedClass<16>
{ {
const GSLocalMemory* m_mem; const GSLocalMemory* m_mem;
DWORD m_CBP[2]; uint32 m_CBP[2];
WORD* m_clut; uint16* m_clut;
DWORD* m_buff32; uint32* m_buff32;
UINT64* m_buff64; uint64* m_buff64;
__declspec(align(16)) struct WriteState __declspec(align(16)) struct WriteState
{ {
@ -73,24 +73,24 @@ __declspec(align(16)) class GSClut : public GSAlignedClass<16>
void WriteCLUT_NULL(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT) {} void WriteCLUT_NULL(const GIFRegTEX0& TEX0, const GIFRegTEXCLUT& TEXCLUT) {}
static void WriteCLUT_T32_I8_CSM1(const DWORD* RESTRICT src, WORD* RESTRICT clut); static void WriteCLUT_T32_I8_CSM1(const uint32* RESTRICT src, uint16* RESTRICT clut);
static void WriteCLUT_T32_I4_CSM1(const DWORD* RESTRICT src, WORD* RESTRICT clut); static void WriteCLUT_T32_I4_CSM1(const uint32* RESTRICT src, uint16* RESTRICT clut);
static void WriteCLUT_T16_I8_CSM1(const WORD* RESTRICT src, WORD* RESTRICT clut); static void WriteCLUT_T16_I8_CSM1(const uint16* RESTRICT src, uint16* RESTRICT clut);
static void WriteCLUT_T16_I4_CSM1(const WORD* RESTRICT src, WORD* RESTRICT clut); static void WriteCLUT_T16_I4_CSM1(const uint16* RESTRICT src, uint16* RESTRICT clut);
static void ReadCLUT_T32_I8(const WORD* RESTRICT clut, DWORD* RESTRICT dst); static void ReadCLUT_T32_I8(const uint16* RESTRICT clut, uint32* RESTRICT dst);
static void ReadCLUT_T32_I4(const WORD* RESTRICT clut, DWORD* RESTRICT dst); static void ReadCLUT_T32_I4(const uint16* RESTRICT clut, uint32* RESTRICT dst);
static void ReadCLUT_T32_I4(const WORD* RESTRICT clut, DWORD* RESTRICT dst32, UINT64* RESTRICT dst64); static void ReadCLUT_T32_I4(const uint16* RESTRICT clut, uint32* RESTRICT dst32, uint64* RESTRICT dst64);
static void ReadCLUT_T16_I8(const WORD* RESTRICT clut, DWORD* RESTRICT dst); static void ReadCLUT_T16_I8(const uint16* RESTRICT clut, uint32* RESTRICT dst);
static void ReadCLUT_T16_I4(const WORD* RESTRICT clut, DWORD* RESTRICT dst); static void ReadCLUT_T16_I4(const uint16* RESTRICT clut, uint32* RESTRICT dst);
static void ReadCLUT_T16_I4(const WORD* RESTRICT clut, DWORD* RESTRICT dst32, UINT64* RESTRICT dst64); static void ReadCLUT_T16_I4(const uint16* RESTRICT clut, uint32* RESTRICT dst32, uint64* RESTRICT dst64);
static void ExpandCLUT64_T32_I8(const DWORD* RESTRICT src, UINT64* RESTRICT dst); static void ExpandCLUT64_T32_I8(const uint32* RESTRICT src, uint64* RESTRICT dst);
static void ExpandCLUT64_T32(const GSVector4i& hi, const GSVector4i& lo0, const GSVector4i& lo1, const GSVector4i& lo2, const GSVector4i& lo3, GSVector4i* dst); static void ExpandCLUT64_T32(const GSVector4i& hi, const GSVector4i& lo0, const GSVector4i& lo1, const GSVector4i& lo2, const GSVector4i& lo3, GSVector4i* dst);
static void ExpandCLUT64_T32(const GSVector4i& hi, const GSVector4i& lo, GSVector4i* dst); static void ExpandCLUT64_T32(const GSVector4i& hi, const GSVector4i& lo, GSVector4i* dst);
static void ExpandCLUT64_T16_I8(const DWORD* RESTRICT src, UINT64* RESTRICT dst); static void ExpandCLUT64_T16_I8(const uint32* RESTRICT src, uint64* RESTRICT dst);
static void ExpandCLUT64_T16(const GSVector4i& hi, const GSVector4i& lo0, const GSVector4i& lo1, const GSVector4i& lo2, const GSVector4i& lo3, GSVector4i* dst); static void ExpandCLUT64_T16(const GSVector4i& hi, const GSVector4i& lo0, const GSVector4i& lo1, const GSVector4i& lo2, const GSVector4i& lo3, GSVector4i* dst);
static void ExpandCLUT64_T16(const GSVector4i& hi, const GSVector4i& lo, GSVector4i* dst); static void ExpandCLUT64_T16(const GSVector4i& hi, const GSVector4i& lo, GSVector4i* dst);
static void Expand16(const WORD* RESTRICT src, DWORD* RESTRICT dst, int w, const GIFRegTEXA& TEXA); static void Expand16(const uint16* RESTRICT src, uint32* RESTRICT dst, int w, const GIFRegTEXA& TEXA);
public: public:
GSClut(const GSLocalMemory* mem); GSClut(const GSLocalMemory* mem);
@ -103,8 +103,8 @@ public:
void Read32(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA); void Read32(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA);
void GetAlphaMinMax32(int& amin, int& amax); void GetAlphaMinMax32(int& amin, int& amax);
DWORD operator [] (size_t i) const {return m_buff32[i];} uint32 operator [] (size_t i) const {return m_buff32[i];}
operator const DWORD*() const {return m_buff32;} operator const uint32*() const {return m_buff32;}
operator const UINT64*() const {return m_buff64;} operator const uint64*() const {return m_buff64;}
}; };

4
plugins/GSdx/GSCodeBuffer.cpp
View File

@ -47,14 +47,14 @@ void* GSCodeBuffer::GetBuffer(size_t size)
if(m_ptr == NULL || m_pos + size > m_blocksize) if(m_ptr == NULL || m_pos + size > m_blocksize)
{ {
m_ptr = (BYTE*)VirtualAlloc(NULL, m_blocksize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE); m_ptr = (uint8*)VirtualAlloc(NULL, m_blocksize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
m_pos = 0; m_pos = 0;
m_buffers.push_back(m_ptr); m_buffers.push_back(m_ptr);
} }
BYTE* ptr = &m_ptr[m_pos]; uint8* ptr = &m_ptr[m_pos];
m_reserved = size; m_reserved = size;

2
plugins/GSdx/GSCodeBuffer.h
View File

@ -26,7 +26,7 @@ class GSCodeBuffer
list<void*> m_buffers; list<void*> m_buffers;
size_t m_blocksize; size_t m_blocksize;
size_t m_pos, m_reserved; size_t m_pos, m_reserved;
BYTE* m_ptr; uint8* m_ptr;
public: public:
GSCodeBuffer(size_t blocksize = 4096 * 64); // 256k GSCodeBuffer(size_t blocksize = 4096 * 64); // 256k

6
plugins/GSdx/GSCrc.cpp
View File

@ -131,9 +131,9 @@ CRC::Game CRC::m_games[] =
{0xFB236A46, SonicUnleashed, US}, {0xFB236A46, SonicUnleashed, US},
}; };
hash_map<DWORD, CRC::Game*> CRC::m_map; hash_map<uint32, CRC::Game*> CRC::m_map;
CRC::Game CRC::Lookup(DWORD crc) CRC::Game CRC::Lookup(uint32 crc)
{ {
if(m_map.empty()) if(m_map.empty())
{ {
@ -143,7 +143,7 @@ CRC::Game CRC::Lookup(DWORD crc)
} }
} }
hash_map<DWORD, Game*>::iterator i = m_map.find(crc); hash_map<uint32, Game*>::iterator i = m_map.find(crc);
if(i != m_map.end()) if(i != m_map.end())
{ {

6
plugins/GSdx/GSCrc.h
View File

@ -84,15 +84,15 @@ public:
struct Game struct Game
{ {
DWORD crc; uint32 crc;
Title title; Title title;
Region region; Region region;
}; };
private: private:
static Game m_games[]; static Game m_games[];
static hash_map<DWORD, Game*> m_map; static hash_map<uint32, Game*> m_map;
public: public:
static Game Lookup(DWORD crc); static Game Lookup(uint32 crc);
}; };

22
plugins/GSdx/GSDevice.h
View File

@ -115,7 +115,7 @@ public:
virtual bool IsLost() = 0; virtual bool IsLost() = 0;
virtual void Present(const CRect& r) = 0; virtual void Present(const GSVector4i& r) = 0;
virtual void BeginScene() = 0; virtual void BeginScene() = 0;
@ -127,11 +127,11 @@ public:
virtual void ClearRenderTarget(Texture& t, const GSVector4& c) = 0; virtual void ClearRenderTarget(Texture& t, const GSVector4& c) = 0;
virtual void ClearRenderTarget(Texture& t, DWORD c) = 0; virtual void ClearRenderTarget(Texture& t, uint32 c) = 0;
virtual void ClearDepth(Texture& t, float c) = 0; virtual void ClearDepth(Texture& t, float c) = 0;
virtual void ClearStencil(Texture& t, BYTE c) = 0; virtual void ClearStencil(Texture& t, uint8 c) = 0;
virtual bool CreateRenderTarget(Texture& t, int w, int h, int format = 0) virtual bool CreateRenderTarget(Texture& t, int w, int h, int format = 0)
{ {
@ -178,11 +178,11 @@ public:
t = m_current; t = m_current;
} }
void Merge(Texture* st, GSVector4* sr, GSVector4* dr, CSize fs, bool slbg, bool mmod, GSVector4& c) void Merge(Texture* st, GSVector4* sr, GSVector4* dr, const GSVector2i& fs, bool slbg, bool mmod, GSVector4& c)
{ {
if(!m_merge || m_merge.GetWidth() != fs.cx || m_merge.GetHeight() != fs.cy) if(!m_merge || m_merge.GetWidth() != fs.x || m_merge.GetHeight() != fs.y)
{ {
CreateRenderTarget(m_merge, fs.cx, fs.cy); CreateRenderTarget(m_merge, fs.x, fs.y);
} }
// TODO: m_1x1 // TODO: m_1x1
@ -192,11 +192,11 @@ public:
m_current = m_merge; m_current = m_merge;
} }
bool Interlace(CSize ds, int field, int mode, float yoffset) bool Interlace(const GSVector2i& ds, int field, int mode, float yoffset)
{ {
if(!m_weavebob || m_weavebob.GetWidth() != ds.cx || m_weavebob.GetHeight() != ds.cy) if(!m_weavebob || m_weavebob.GetWidth() != ds.x || m_weavebob.GetHeight() != ds.y)
{ {
CreateRenderTarget(m_weavebob, ds.cx, ds.cy); CreateRenderTarget(m_weavebob, ds.x, ds.y);
} }
if(mode == 0 || mode == 2) // weave or blend if(mode == 0 || mode == 2) // weave or blend
@ -209,9 +209,9 @@ public:
{ {
// blend // blend
if(!m_blend || m_blend.GetWidth() != ds.cx || m_blend.GetHeight() != ds.cy) if(!m_blend || m_blend.GetWidth() != ds.x || m_blend.GetHeight() != ds.y)
{ {
CreateRenderTarget(m_blend, ds.cx, ds.cy); CreateRenderTarget(m_blend, ds.x, ds.y);
} }
DoInterlace(m_weavebob, m_blend, 2, false, 0); DoInterlace(m_weavebob, m_blend, 2, false, 0);

54
plugins/GSdx/GSDevice10.cpp
View File

@ -80,7 +80,7 @@ bool GSDevice10::Create(HWND hWnd, bool vsync)
scd.SampleDesc.Quality = 0; scd.SampleDesc.Quality = 0;
scd.Windowed = TRUE; scd.Windowed = TRUE;
UINT flags = 0; uint32 flags = 0;
#ifdef DEBUG #ifdef DEBUG
flags |= D3D10_CREATE_DEVICE_DEBUG; flags |= D3D10_CREATE_DEVICE_DEBUG;
@ -256,15 +256,15 @@ bool GSDevice10::Reset(int w, int h, bool fs)
return true; return true;
} }
void GSDevice10::Present(const CRect& r) void GSDevice10::Present(const GSVector4i& r)
{ {
CRect cr; GSVector4i cr;
GetClientRect(m_hWnd, &cr); GetClientRect(m_hWnd, cr);
if(m_backbuffer.GetWidth() != cr.Width() || m_backbuffer.GetHeight() != cr.Height()) if(m_backbuffer.GetWidth() != cr.width() || m_backbuffer.GetHeight() != cr.height())
{ {
Reset(cr.Width(), cr.Height(), false); Reset(cr.width(), cr.height(), false);
} }
float color[4] = {0, 0, 0, 0}; float color[4] = {0, 0, 0, 0};
@ -306,13 +306,13 @@ void GSDevice10::Draw(const string& s)
OMSetRenderTargets(m_backbuffer, NULL); OMSetRenderTargets(m_backbuffer, NULL);
CRect r(0, 0, m_backbuffer.GetWidth(), m_backbuffer.GetHeight()); GSVector4i r(0, 0, m_backbuffer.GetWidth(), m_backbuffer.GetHeight());
D3DCOLOR c = D3DCOLOR_ARGB(255, 0, 255, 0); D3DCOLOR c = D3DCOLOR_ARGB(255, 0, 255, 0);
if(m_font->DrawText(NULL, str, -1, &r, DT_CALCRECT|DT_LEFT|DT_WORDBREAK, c)) if(m_font->DrawText(NULL, str, -1, r, DT_CALCRECT|DT_LEFT|DT_WORDBREAK, c))
{ {
m_font->DrawText(NULL, str, -1, &r, DT_LEFT|DT_WORDBREAK, c); m_font->DrawText(NULL, str, -1, r, DT_LEFT|DT_WORDBREAK, c);
} }
EndScene(); EndScene();
@ -360,7 +360,7 @@ void GSDevice10::ClearRenderTarget(Texture& t, const GSVector4& c)
m_dev->ClearRenderTargetView(t, c.v); m_dev->ClearRenderTargetView(t, c.v);
} }
void GSDevice10::ClearRenderTarget(Texture& t, DWORD c) void GSDevice10::ClearRenderTarget(Texture& t, uint32 c)
{ {
GSVector4 color = GSVector4(c) * (1.0f / 255); GSVector4 color = GSVector4(c) * (1.0f / 255);
@ -372,7 +372,7 @@ void GSDevice10::ClearDepth(Texture& t, float c)
m_dev->ClearDepthStencilView(t, D3D10_CLEAR_DEPTH, c, 0); m_dev->ClearDepthStencilView(t, D3D10_CLEAR_DEPTH, c, 0);
} }
void GSDevice10::ClearStencil(Texture& t, BYTE c) void GSDevice10::ClearStencil(Texture& t, uint8 c)
{ {
m_dev->ClearDepthStencilView(t, D3D10_CLEAR_STENCIL, 0, c); m_dev->ClearDepthStencilView(t, D3D10_CLEAR_STENCIL, 0, c);
} }
@ -487,11 +487,11 @@ void GSDevice10::DoInterlace(Texture& st, Texture& dt, int shader, bool linear,
StretchRect(st, sr, dt, dr, m_interlace.ps[shader], m_interlace.cb, linear); StretchRect(st, sr, dt, dr, m_interlace.ps[shader], m_interlace.cb, linear);
} }
void GSDevice10::IASetVertexBuffer(ID3D10Buffer* vb, UINT stride) void GSDevice10::IASetVertexBuffer(ID3D10Buffer* vb, size_t stride)
{ {
if(m_vb != vb || m_vb_stride != stride) if(m_vb != vb || m_vb_stride != stride)
{ {
UINT offset = 0; uint32 offset = 0;
m_dev->IASetVertexBuffers(0, 1, &vb, &stride, &offset); m_dev->IASetVertexBuffers(0, 1, &vb, &stride, &offset);
@ -590,9 +590,9 @@ void GSDevice10::PSSetSamplerState(ID3D10SamplerState* ss0, ID3D10SamplerState*
} }
} }
void GSDevice10::RSSet(int width, int height, const RECT* scissor) void GSDevice10::RSSet(int width, int height, const GSVector4i* scissor)
{ {
if(m_viewport.cx != width || m_viewport.cy != height) if(m_viewport.x != width || m_viewport.y != height)
{ {
D3D10_VIEWPORT vp; D3D10_VIEWPORT vp;
@ -607,20 +607,20 @@ void GSDevice10::RSSet(int width, int height, const RECT* scissor)
m_dev->RSSetViewports(1, &vp); m_dev->RSSetViewports(1, &vp);
m_viewport = CSize(width, height); m_viewport = GSVector2i(width, height);
} }
CRect r = scissor ? *scissor : CRect(0, 0, width, height); GSVector4i r = scissor ? *scissor : GSVector4i(0, 0, width, height);
if(m_scissor != r) if(!m_scissor.eq(r))
{ {
m_dev->RSSetScissorRects(1, &r); m_dev->RSSetScissorRects(1, r);
m_scissor = r; m_scissor = r;
} }
} }
void GSDevice10::OMSetDepthStencilState(ID3D10DepthStencilState* dss, UINT sref) void GSDevice10::OMSetDepthStencilState(ID3D10DepthStencilState* dss, uint8 sref)
{ {
if(m_dss != dss || m_sref != sref) if(m_dss != dss || m_sref != sref)
{ {
@ -655,7 +655,7 @@ void GSDevice10::OMSetRenderTargets(ID3D10RenderTargetView* rtv, ID3D10DepthSten
} }
} }
void GSDevice10::DrawPrimitive(UINT count, UINT start) void GSDevice10::DrawPrimitive(uint32 count, uint32 start)
{ {
m_dev->Draw(count, start); m_dev->Draw(count, start);
} }
@ -735,7 +735,7 @@ void GSDevice10::StretchRect(Texture& st, const GSVector4& sr, Texture& dt, cons
EndScene(); EndScene();
} }
HRESULT GSDevice10::CompileShader(UINT id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10VertexShader** ps, D3D10_INPUT_ELEMENT_DESC* layout, int count, ID3D10InputLayout** il) HRESULT GSDevice10::CompileShader(uint32 id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10VertexShader** ps, D3D10_INPUT_ELEMENT_DESC* layout, int count, ID3D10InputLayout** il)
{ {
HRESULT hr; HRESULT hr;
@ -753,7 +753,7 @@ HRESULT GSDevice10::CompileShader(UINT id, const string& entry, D3D10_SHADER_MAC
return hr; return hr;
} }
hr = m_dev->CreateVertexShader((DWORD*)shader->GetBufferPointer(), shader->GetBufferSize(), ps); hr = m_dev->CreateVertexShader((void*)shader->GetBufferPointer(), shader->GetBufferSize(), ps);
if(FAILED(hr)) if(FAILED(hr))
{ {
@ -770,7 +770,7 @@ HRESULT GSDevice10::CompileShader(UINT id, const string& entry, D3D10_SHADER_MAC
return hr; return hr;
} }
HRESULT GSDevice10::CompileShader(UINT id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10GeometryShader** gs) HRESULT GSDevice10::CompileShader(uint32 id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10GeometryShader** gs)
{ {
HRESULT hr; HRESULT hr;
@ -788,7 +788,7 @@ HRESULT GSDevice10::CompileShader(UINT id, const string& entry, D3D10_SHADER_MAC
return hr; return hr;
} }
hr = m_dev->CreateGeometryShader((DWORD*)shader->GetBufferPointer(), shader->GetBufferSize(), gs); hr = m_dev->CreateGeometryShader((void*)shader->GetBufferPointer(), shader->GetBufferSize(), gs);
if(FAILED(hr)) if(FAILED(hr))
{ {
@ -798,7 +798,7 @@ HRESULT GSDevice10::CompileShader(UINT id, const string& entry, D3D10_SHADER_MAC
return hr; return hr;
} }
HRESULT GSDevice10::CompileShader(UINT id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10PixelShader** ps) HRESULT GSDevice10::CompileShader(uint32 id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10PixelShader** ps)
{ {
HRESULT hr; HRESULT hr;
@ -816,7 +816,7 @@ HRESULT GSDevice10::CompileShader(UINT id, const string& entry, D3D10_SHADER_MAC
return hr; return hr;
} }
hr = m_dev->CreatePixelShader((DWORD*)shader->GetBufferPointer(), shader->GetBufferSize(), ps); hr = m_dev->CreatePixelShader((void*)shader->GetBufferPointer(), shader->GetBufferSize(), ps);
if(FAILED(hr)) if(FAILED(hr))
{ {

30
plugins/GSdx/GSDevice10.h
View File

@ -33,8 +33,8 @@ private:
// state cache // state cache
ID3D10Buffer* m_vb; ID3D10Buffer* m_vb;
UINT m_vb_count; int m_vb_count;
UINT m_vb_stride; size_t m_vb_stride;
ID3D10InputLayout* m_layout; ID3D10InputLayout* m_layout;
D3D10_PRIMITIVE_TOPOLOGY m_topology; D3D10_PRIMITIVE_TOPOLOGY m_topology;
ID3D10VertexShader* m_vs; ID3D10VertexShader* m_vs;
@ -44,10 +44,10 @@ private:
ID3D10PixelShader* m_ps; ID3D10PixelShader* m_ps;
ID3D10Buffer* m_ps_cb; ID3D10Buffer* m_ps_cb;
ID3D10SamplerState* m_ps_ss[2]; ID3D10SamplerState* m_ps_ss[2];
CSize m_viewport; GSVector2i m_viewport;
CRect m_scissor; GSVector4i m_scissor;
ID3D10DepthStencilState* m_dss; ID3D10DepthStencilState* m_dss;
UINT m_sref; uint8 m_sref;
ID3D10BlendState* m_bs; ID3D10BlendState* m_bs;
float m_bf; float m_bf;
ID3D10RenderTargetView* m_rtv; ID3D10RenderTargetView* m_rtv;
@ -100,16 +100,16 @@ public:
bool Create(HWND hWnd, bool vsync); bool Create(HWND hWnd, bool vsync);
bool Reset(int w, int h, bool fs); bool Reset(int w, int h, bool fs);
bool IsLost() {return false;} bool IsLost() {return false;}
void Present(const CRect& r); void Present(const GSVector4i& r);
void BeginScene(); void BeginScene();
void EndScene(); void EndScene();
void Draw(const string& s); void Draw(const string& s);
bool CopyOffscreen(Texture& src, const GSVector4& sr, Texture& dst, int w, int h, int format = 0); bool CopyOffscreen(Texture& src, const GSVector4& sr, Texture& dst, int w, int h, int format = 0);
void ClearRenderTarget(Texture& t, const GSVector4& c); void ClearRenderTarget(Texture& t, const GSVector4& c);
void ClearRenderTarget(Texture& t, DWORD c); void ClearRenderTarget(Texture& t, uint32 c);
void ClearDepth(Texture& t, float c); void ClearDepth(Texture& t, float c);
void ClearStencil(Texture& t, BYTE c); void ClearStencil(Texture& t, uint8 c);
bool CreateRenderTarget(Texture& t, int w, int h, int format = 0); bool CreateRenderTarget(Texture& t, int w, int h, int format = 0);
bool CreateDepthStencil(Texture& t, int w, int h, int format = 0); bool CreateDepthStencil(Texture& t, int w, int h, int format = 0);
@ -119,7 +119,7 @@ public:
ID3D10Device* operator->() {return m_dev;} ID3D10Device* operator->() {return m_dev;}
operator ID3D10Device*() {return m_dev;} operator ID3D10Device*() {return m_dev;}
void IASetVertexBuffer(ID3D10Buffer* vb, UINT stride); void IASetVertexBuffer(ID3D10Buffer* vb, size_t stride);
void IASetInputLayout(ID3D10InputLayout* layout); void IASetInputLayout(ID3D10InputLayout* layout);
void IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY topology); void IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY topology);
void VSSetShader(ID3D10VertexShader* vs, ID3D10Buffer* vs_cb); void VSSetShader(ID3D10VertexShader* vs, ID3D10Buffer* vs_cb);
@ -127,18 +127,18 @@ public:
void PSSetShaderResources(ID3D10ShaderResourceView* srv0, ID3D10ShaderResourceView* srv1); void PSSetShaderResources(ID3D10ShaderResourceView* srv0, ID3D10ShaderResourceView* srv1);
void PSSetShader(ID3D10PixelShader* ps, ID3D10Buffer* ps_cb); void PSSetShader(ID3D10PixelShader* ps, ID3D10Buffer* ps_cb);
void PSSetSamplerState(ID3D10SamplerState* ss0, ID3D10SamplerState* ss1); void PSSetSamplerState(ID3D10SamplerState* ss0, ID3D10SamplerState* ss1);
void RSSet(int width, int height, const RECT* scissor = NULL); void RSSet(int width, int height, const GSVector4i* scissor = NULL);
void OMSetDepthStencilState(ID3D10DepthStencilState* dss, UINT sref); void OMSetDepthStencilState(ID3D10DepthStencilState* dss, uint8 sref);
void OMSetBlendState(ID3D10BlendState* bs, float bf); void OMSetBlendState(ID3D10BlendState* bs, float bf);
void OMSetRenderTargets(ID3D10RenderTargetView* rtv, ID3D10DepthStencilView* dsv); void OMSetRenderTargets(ID3D10RenderTargetView* rtv, ID3D10DepthStencilView* dsv);
void DrawPrimitive(UINT count, UINT start = 0); void DrawPrimitive(uint32 count, uint32 start = 0);
void StretchRect(Texture& st, Texture& dt, const GSVector4& dr, bool linear = true); void StretchRect(Texture& st, Texture& dt, const GSVector4& dr, bool linear = true);
void StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const GSVector4& dr, bool linear = true); void StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const GSVector4& dr, bool linear = true);
void StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const GSVector4& dr, ID3D10PixelShader* ps, ID3D10Buffer* ps_cb, bool linear = true); void StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const GSVector4& dr, ID3D10PixelShader* ps, ID3D10Buffer* ps_cb, bool linear = true);
void StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const GSVector4& dr, ID3D10PixelShader* ps, ID3D10Buffer* ps_cb, ID3D10BlendState* bs, bool linear = true); void StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const GSVector4& dr, ID3D10PixelShader* ps, ID3D10Buffer* ps_cb, ID3D10BlendState* bs, bool linear = true);
HRESULT CompileShader(UINT id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10VertexShader** vs, D3D10_INPUT_ELEMENT_DESC* layout, int count, ID3D10InputLayout** il); HRESULT CompileShader(uint32 id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10VertexShader** vs, D3D10_INPUT_ELEMENT_DESC* layout, int count, ID3D10InputLayout** il);
HRESULT CompileShader(UINT id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10GeometryShader** gs); HRESULT CompileShader(uint32 id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10GeometryShader** gs);
HRESULT CompileShader(UINT id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10PixelShader** ps); HRESULT CompileShader(uint32 id, const string& entry, D3D10_SHADER_MACRO* macro, ID3D10PixelShader** ps);
}; };

19
plugins/GSdx/GSDevice7.cpp
View File

@ -112,7 +112,7 @@ bool GSDevice7::Reset(int w, int h, bool fs)
HRGN hrgn = CreateRectRgn(0, 0, w, h); HRGN hrgn = CreateRectRgn(0, 0, w, h);
BYTE buff[1024]; uint8 buff[1024];
GetRegionData(hrgn, sizeof(buff), (RGNDATA*)buff); GetRegionData(hrgn, sizeof(buff), (RGNDATA*)buff);
@ -129,12 +129,13 @@ bool GSDevice7::Reset(int w, int h, bool fs)
return true; return true;
} }
void GSDevice7::Present(const CRect& r) void GSDevice7::Present(const GSVector4i& r)
{ {
HRESULT hr; HRESULT hr;
CRect cr; GSVector4i cr;
GetClientRect(m_hWnd, &cr);
GetClientRect(m_hWnd, cr);
DDSURFACEDESC2 desc; DDSURFACEDESC2 desc;
memset(&desc, 0, sizeof(desc)); memset(&desc, 0, sizeof(desc));
@ -142,9 +143,9 @@ void GSDevice7::Present(const CRect& r)
hr = m_backbuffer->GetSurfaceDesc(&desc); hr = m_backbuffer->GetSurfaceDesc(&desc);
if(desc.dwWidth != cr.Width() || desc.dwHeight != cr.Height()) if(desc.dwWidth != cr.width() || desc.dwHeight != cr.height())
{ {
Reset(cr.Width(), cr.Height(), false); Reset(cr.width(), cr.height(), false);
} }
DDBLTFX fx; DDBLTFX fx;
@ -156,9 +157,9 @@ void GSDevice7::Present(const CRect& r)
hr = m_backbuffer->Blt(NULL, NULL, NULL, DDBLT_WAIT | DDBLT_COLORFILL, &fx); hr = m_backbuffer->Blt(NULL, NULL, NULL, DDBLT_WAIT | DDBLT_COLORFILL, &fx);
CRect r2 = r; GSVector4i r2 = r;
hr = m_backbuffer->Blt(&r2, m_merge, NULL, DDBLT_WAIT, NULL); hr = m_backbuffer->Blt(r2, m_merge, NULL, DDBLT_WAIT, NULL);
r2 = cr; r2 = cr;
@ -169,7 +170,7 @@ void GSDevice7::Present(const CRect& r)
hr = m_dd->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN, NULL); hr = m_dd->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN, NULL);
} }
hr = m_primary->Blt(&r2, m_backbuffer, &cr, DDBLT_WAIT, NULL); hr = m_primary->Blt(r2, m_backbuffer, cr, DDBLT_WAIT, NULL);
if(hr == DDERR_SURFACELOST) if(hr == DDERR_SURFACELOST)
{ {

6
plugins/GSdx/GSDevice7.h
View File

@ -45,14 +45,14 @@ public:
bool Create(HWND hWnd, bool vsync); bool Create(HWND hWnd, bool vsync);
bool Reset(int w, int h, bool fs); bool Reset(int w, int h, bool fs);
bool IsLost() {return false;} bool IsLost() {return false;}
void Present(const CRect& r); void Present(const GSVector4i& r);
void BeginScene() {} void BeginScene() {}
void EndScene() {} void EndScene() {}
void Draw(const string& s) {} void Draw(const string& s) {}
bool CopyOffscreen(Texture& src, const GSVector4& sr, Texture& dst, int w, int h, int format = 0) {return false;} bool CopyOffscreen(Texture& src, const GSVector4& sr, Texture& dst, int w, int h, int format = 0) {return false;}
void ClearRenderTarget(Texture& t, const GSVector4& c) {} void ClearRenderTarget(Texture& t, const GSVector4& c) {}
void ClearRenderTarget(Texture& t, DWORD c) {} void ClearRenderTarget(Texture& t, uint32 c) {}
void ClearDepth(Texture& t, float c) {} void ClearDepth(Texture& t, float c) {}
void ClearStencil(Texture& t, BYTE c) {} void ClearStencil(Texture& t, uint8 c) {}
}; };

54
plugins/GSdx/GSDevice9.cpp
View File

@ -237,7 +237,7 @@ bool GSDevice9::Reset(int w, int h, bool fs)
m_ps_cb = NULL; m_ps_cb = NULL;
m_ps_cb_len = 0; m_ps_cb_len = 0;
m_ps_ss = NULL; m_ps_ss = NULL;
m_scissor = CRect(0, 0, 0, 0); m_scissor = GSVector4i::zero();
m_dss = NULL; m_dss = NULL;
m_sref = 0; m_sref = 0;
m_bs = NULL; m_bs = NULL;
@ -280,7 +280,7 @@ bool GSDevice9::Reset(int w, int h, bool fs)
if(!m_dev) if(!m_dev)
{ {
UINT flags = D3DCREATE_MULTITHREADED | (m_d3dcaps.VertexProcessingCaps ? D3DCREATE_HARDWARE_VERTEXPROCESSING : D3DCREATE_SOFTWARE_VERTEXPROCESSING); uint32 flags = D3DCREATE_MULTITHREADED | (m_d3dcaps.VertexProcessingCaps ? D3DCREATE_HARDWARE_VERTEXPROCESSING : D3DCREATE_SOFTWARE_VERTEXPROCESSING);
hr = m_d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hWnd, flags, &m_pp, &m_dev); hr = m_d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hWnd, flags, &m_pp, &m_dev);
@ -347,15 +347,15 @@ bool GSDevice9::IsLost()
return hr == D3DERR_DEVICELOST || hr == D3DERR_DEVICENOTRESET; return hr == D3DERR_DEVICELOST || hr == D3DERR_DEVICENOTRESET;
} }
void GSDevice9::Present(const CRect& r) void GSDevice9::Present(const GSVector4i& r)
{ {
CRect cr; GSVector4i cr;
GetClientRect(m_hWnd, &cr); GetClientRect(m_hWnd, cr);
if(m_backbuffer.GetWidth() != cr.Width() || m_backbuffer.GetHeight() != cr.Height()) if(m_backbuffer.GetWidth() != cr.width() || m_backbuffer.GetHeight() != cr.height())
{ {
Reset(cr.Width(), cr.Height(), false); Reset(cr.width(), cr.height(), false);
} }
OMSetRenderTargets(m_backbuffer, NULL); OMSetRenderTargets(m_backbuffer, NULL);
@ -396,13 +396,13 @@ void GSDevice9::Draw(const string& s)
OMSetRenderTargets(m_backbuffer, NULL); OMSetRenderTargets(m_backbuffer, NULL);
CRect r(0, 0, m_backbuffer.GetWidth(), m_backbuffer.GetHeight()); GSVector4i r(0, 0, m_backbuffer.GetWidth(), m_backbuffer.GetHeight());
D3DCOLOR c = D3DCOLOR_ARGB(255, 0, 255, 0); D3DCOLOR c = D3DCOLOR_ARGB(255, 0, 255, 0);
if(m_font->DrawText(NULL, str, -1, &r, DT_CALCRECT|DT_LEFT|DT_WORDBREAK, c)) if(m_font->DrawText(NULL, str, -1, r, DT_CALCRECT|DT_LEFT|DT_WORDBREAK, c))
{ {
m_font->DrawText(NULL, str, -1, &r, DT_LEFT|DT_WORDBREAK, c); m_font->DrawText(NULL, str, -1, r, DT_LEFT|DT_WORDBREAK, c);
} }
EndScene(); EndScene();
@ -447,10 +447,10 @@ bool GSDevice9::CopyOffscreen(Texture& src, const GSVector4& sr, Texture& dst, i
void GSDevice9::ClearRenderTarget(Texture& t, const GSVector4& c) void GSDevice9::ClearRenderTarget(Texture& t, const GSVector4& c)
{ {
ClearRenderTarget(t, D3DCOLOR_RGBA((BYTE)(c.r * 255 + 0.5f), (BYTE)(c.g * 255 + 0.5f), (BYTE)(c.b * 255 + 0.5f), (BYTE)(c.a * 255 + 0.5f))); ClearRenderTarget(t, (c * 255 + 0.5f).zyxw().rgba32());
} }
void GSDevice9::ClearRenderTarget(Texture& t, DWORD c) void GSDevice9::ClearRenderTarget(Texture& t, uint32 c)
{ {
CComPtr<IDirect3DSurface9> surface; CComPtr<IDirect3DSurface9> surface;
m_dev->GetRenderTarget(0, &surface); m_dev->GetRenderTarget(0, &surface);
@ -468,7 +468,7 @@ void GSDevice9::ClearDepth(Texture& t, float c)
m_dev->SetDepthStencilSurface(surface); m_dev->SetDepthStencilSurface(surface);
} }
void GSDevice9::ClearStencil(Texture& t, BYTE c) void GSDevice9::ClearStencil(Texture& t, uint8 c)
{ {
CComPtr<IDirect3DSurface9> surface; CComPtr<IDirect3DSurface9> surface;
m_dev->GetDepthStencilSurface(&surface); m_dev->GetDepthStencilSurface(&surface);
@ -580,7 +580,7 @@ void GSDevice9::DoInterlace(Texture& st, Texture& dt, int shader, bool linear, f
StretchRect(st, sr, dt, dr, m_interlace.ps[shader], (const float*)&cb, 1, linear); StretchRect(st, sr, dt, dr, m_interlace.ps[shader], (const float*)&cb, 1, linear);
} }
/* /*
void GSDevice9::IASetVertexBuffer(IDirect3DVertexBuffer9* vb, UINT count, const void* vertices, UINT stride) void GSDevice9::IASetVertexBuffer(IDirect3DVertexBuffer9* vb, uint32 count, const void* vertices, size_t stride)
{ {
void* data = NULL; void* data = NULL;
@ -600,7 +600,7 @@ void GSDevice9::IASetVertexBuffer(IDirect3DVertexBuffer9* vb, UINT count, const
} }
} }
*/ */
void GSDevice9::IASetVertexBuffer(UINT count, const void* vertices, UINT stride) void GSDevice9::IASetVertexBuffer(int count, const void* vertices, size_t stride)
{ {
m_vb_count = count; m_vb_count = count;
m_vb_vertices = vertices; m_vb_vertices = vertices;
@ -728,19 +728,19 @@ void GSDevice9::PSSetSamplerState(Direct3DSamplerState9* ss)
} }
} }
void GSDevice9::RSSet(int width, int height, const RECT* scissor) void GSDevice9::RSSet(int width, int height, const GSVector4i* scissor)
{ {
CRect r = scissor ? *scissor : CRect(0, 0, width, height); GSVector4i r = scissor ? *scissor : GSVector4i(0, 0, width, height);
if(m_scissor != r) if(!m_scissor.eq(r))
{ {
m_dev->SetScissorRect(&r); m_dev->SetScissorRect(r);
m_scissor = r; m_scissor = r;
} }
} }
void GSDevice9::OMSetDepthStencilState(Direct3DDepthStencilState9* dss, UINT sref) void GSDevice9::OMSetDepthStencilState(Direct3DDepthStencilState9* dss, uint32 sref)
{ {
if(m_dss != dss || m_sref != sref) if(m_dss != dss || m_sref != sref)
{ {
@ -770,7 +770,7 @@ void GSDevice9::OMSetDepthStencilState(Direct3DDepthStencilState9* dss, UINT sre
} }
} }
void GSDevice9::OMSetBlendState(Direct3DBlendState9* bs, DWORD bf) void GSDevice9::OMSetBlendState(Direct3DBlendState9* bs, uint32 bf)
{ {
if(m_bs != bs || m_bf != bf) if(m_bs != bs || m_bf != bf)
{ {
@ -914,7 +914,7 @@ void GSDevice9::StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const
// FIXME: D3DXCompileShaderFromResource of d3dx9 v37 (march 2008) calls GetFullPathName on id for some reason and then crashes // FIXME: D3DXCompileShaderFromResource of d3dx9 v37 (march 2008) calls GetFullPathName on id for some reason and then crashes
static HRESULT LoadShader(UINT id, LPCSTR& data, DWORD& size) static HRESULT LoadShader(uint32 id, LPCSTR& data, uint32& size)
{ {
CComPtr<ID3DXBuffer> shader, error; CComPtr<ID3DXBuffer> shader, error;
@ -935,7 +935,7 @@ static HRESULT LoadShader(UINT id, LPCSTR& data, DWORD& size)
return S_OK; return S_OK;
} }
HRESULT GSDevice9::CompileShader(UINT id, const string& entry, const D3DXMACRO* macro, IDirect3DVertexShader9** vs, const D3DVERTEXELEMENT9* layout, int count, IDirect3DVertexDeclaration9** il) HRESULT GSDevice9::CompileShader(uint32 id, const string& entry, const D3DXMACRO* macro, IDirect3DVertexShader9** vs, const D3DVERTEXELEMENT9* layout, int count, IDirect3DVertexDeclaration9** il)
{ {
const char* target; const char* target;
@ -959,7 +959,7 @@ HRESULT GSDevice9::CompileShader(UINT id, const string& entry, const D3DXMACRO*
// FIXME: hr = D3DXCompileShaderFromResource(AfxGetResourceHandle(), MAKEINTRESOURCE(id), macro, NULL, entry.c_str(), target, 0, &shader, &error, NULL); // FIXME: hr = D3DXCompileShaderFromResource(AfxGetResourceHandle(), MAKEINTRESOURCE(id), macro, NULL, entry.c_str(), target, 0, &shader, &error, NULL);
LPCSTR data; LPCSTR data;
DWORD size; uint32 size;
hr = LoadShader(id, data, size); hr = LoadShader(id, data, size);
@ -995,10 +995,10 @@ HRESULT GSDevice9::CompileShader(UINT id, const string& entry, const D3DXMACRO*
return S_OK; return S_OK;
} }
HRESULT GSDevice9::CompileShader(UINT id, const string& entry, const D3DXMACRO* macro, IDirect3DPixelShader9** ps) HRESULT GSDevice9::CompileShader(uint32 id, const string& entry, const D3DXMACRO* macro, IDirect3DPixelShader9** ps)
{ {
const char* target = NULL; const char* target = NULL;
UINT flags = 0; uint32 flags = 0;
if(m_d3dcaps.PixelShaderVersion >= D3DPS_VERSION(3, 0)) if(m_d3dcaps.PixelShaderVersion >= D3DPS_VERSION(3, 0))
{ {
@ -1021,7 +1021,7 @@ HRESULT GSDevice9::CompileShader(UINT id, const string& entry, const D3DXMACRO*
// FIXME: hr = D3DXCompileShaderFromResource(AfxGetResourceHandle(), MAKEINTRESOURCE(id), macro, NULL, entry.c_str(), target, flags, &shader, &error, NULL); // FIXME: hr = D3DXCompileShaderFromResource(AfxGetResourceHandle(), MAKEINTRESOURCE(id), macro, NULL, entry.c_str(), target, flags, &shader, &error, NULL);
LPCSTR data; LPCSTR data;
DWORD size; uint32 size;
hr = LoadShader(id, data, size); hr = LoadShader(id, data, size);

32
plugins/GSdx/GSDevice9.h
View File

@ -67,9 +67,9 @@ private:
// state cache // state cache
IDirect3DVertexBuffer9* m_vb; IDirect3DVertexBuffer9* m_vb;
UINT m_vb_count; int m_vb_count;
const void* m_vb_vertices; const void* m_vb_vertices;
UINT m_vb_stride; size_t m_vb_stride;
IDirect3DVertexDeclaration9* m_layout; IDirect3DVertexDeclaration9* m_layout;
D3DPRIMITIVETYPE m_topology; D3DPRIMITIVETYPE m_topology;
IDirect3DVertexShader9* m_vs; IDirect3DVertexShader9* m_vs;
@ -80,11 +80,11 @@ private:
float* m_ps_cb; float* m_ps_cb;
int m_ps_cb_len; int m_ps_cb_len;
Direct3DSamplerState9* m_ps_ss; Direct3DSamplerState9* m_ps_ss;
CRect m_scissor; GSVector4i m_scissor;
Direct3DDepthStencilState9* m_dss; Direct3DDepthStencilState9* m_dss;
UINT m_sref; uint32 m_sref;
Direct3DBlendState9* m_bs; Direct3DBlendState9* m_bs;
DWORD m_bf; uint32 m_bf;
IDirect3DSurface9* m_rtv; IDirect3DSurface9* m_rtv;
IDirect3DSurface9* m_dsv; IDirect3DSurface9* m_dsv;
@ -136,16 +136,16 @@ public:
bool Create(HWND hWnd, bool vsync); bool Create(HWND hWnd, bool vsync);
bool Reset(int w, int h, bool fs); bool Reset(int w, int h, bool fs);
bool IsLost(); bool IsLost();
void Present(const CRect& r); void Present(const GSVector4i& r);
void BeginScene(); void BeginScene();
void EndScene(); void EndScene();
void Draw(const string& s); void Draw(const string& s);
bool CopyOffscreen(Texture& src, const GSVector4& sr, Texture& dst, int w, int h, int format = 0); bool CopyOffscreen(Texture& src, const GSVector4& sr, Texture& dst, int w, int h, int format = 0);
void ClearRenderTarget(Texture& t, const GSVector4& c); void ClearRenderTarget(Texture& t, const GSVector4& c);
void ClearRenderTarget(Texture& t, DWORD c); void ClearRenderTarget(Texture& t, uint32 c);
void ClearDepth(Texture& t, float c); void ClearDepth(Texture& t, float c);
void ClearStencil(Texture& t, BYTE c); void ClearStencil(Texture& t, uint8 c);
bool CreateRenderTarget(Texture& t, int w, int h, int format = 0); bool CreateRenderTarget(Texture& t, int w, int h, int format = 0);
bool CreateDepthStencil(Texture& t, int w, int h, int format = 0); bool CreateDepthStencil(Texture& t, int w, int h, int format = 0);
@ -155,21 +155,21 @@ public:
IDirect3DDevice9* operator->() {return m_dev;} IDirect3DDevice9* operator->() {return m_dev;}
operator IDirect3DDevice9*() {return m_dev;} operator IDirect3DDevice9*() {return m_dev;}
// TODO: void IASetVertexBuffer(IDirect3DVertexBuffer9* vb, UINT count, const void* vertices, UINT stride); // TODO: void IASetVertexBuffer(IDirect3DVertexBuffer9* vb, uint32 count, const void* vertices, size_t stride);
void IASetVertexBuffer(UINT count, const void* vertices, UINT stride); void IASetVertexBuffer(int count, const void* vertices, size_t stride);
void IASetInputLayout(IDirect3DVertexDeclaration9* layout); void IASetInputLayout(IDirect3DVertexDeclaration9* layout);
void IASetPrimitiveTopology(D3DPRIMITIVETYPE topology); void IASetPrimitiveTopology(D3DPRIMITIVETYPE topology);
void VSSetShader(IDirect3DVertexShader9* vs, const float* vs_cb, int vs_cb_len); void VSSetShader(IDirect3DVertexShader9* vs, const float* vs_cb, int vs_cb_len);
void PSSetShaderResources(IDirect3DTexture9* srv0, IDirect3DTexture9* srv1); void PSSetShaderResources(IDirect3DTexture9* srv0, IDirect3DTexture9* srv1);
void PSSetShader(IDirect3DPixelShader9* ps, const float* ps_cb, int ps_cb_len); void PSSetShader(IDirect3DPixelShader9* ps, const float* ps_cb, int ps_cb_len);
void PSSetSamplerState(Direct3DSamplerState9* ss); void PSSetSamplerState(Direct3DSamplerState9* ss);
void RSSet(int width, int height, const RECT* scissor = NULL); void RSSet(int width, int height, const GSVector4i* scissor = NULL);
void OMSetDepthStencilState(Direct3DDepthStencilState9* dss, UINT sref); void OMSetDepthStencilState(Direct3DDepthStencilState9* dss, uint32 sref);
void OMSetBlendState(Direct3DBlendState9* bs, DWORD bf); void OMSetBlendState(Direct3DBlendState9* bs, uint32 bf);
void OMSetRenderTargets(IDirect3DSurface9* rtv, IDirect3DSurface9* dsv); void OMSetRenderTargets(IDirect3DSurface9* rtv, IDirect3DSurface9* dsv);
void DrawPrimitive(); void DrawPrimitive();
template<class T> void IASetVertexBuffer(UINT count, T* vertices) template<class T> void IASetVertexBuffer(int count, T* vertices)
{ {
IASetVertexBuffer(count, vertices, sizeof(T)); IASetVertexBuffer(count, vertices, sizeof(T));
} }
@ -179,8 +179,8 @@ public:
void StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const GSVector4& dr, IDirect3DPixelShader9* ps, const float* ps_cb, int ps_cb_len, bool linear = true); void StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const GSVector4& dr, IDirect3DPixelShader9* ps, const float* ps_cb, int ps_cb_len, bool linear = true);
void StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const GSVector4& dr, IDirect3DPixelShader9* ps, const float* ps_cb, int ps_cb_len, Direct3DBlendState9* bs, bool linear = true); void StretchRect(Texture& st, const GSVector4& sr, Texture& dt, const GSVector4& dr, IDirect3DPixelShader9* ps, const float* ps_cb, int ps_cb_len, Direct3DBlendState9* bs, bool linear = true);
HRESULT CompileShader(UINT id, const string& entry, const D3DXMACRO* macro, IDirect3DVertexShader9** vs, const D3DVERTEXELEMENT9* layout, int count, IDirect3DVertexDeclaration9** il); HRESULT CompileShader(uint32 id, const string& entry, const D3DXMACRO* macro, IDirect3DVertexShader9** vs, const D3DVERTEXELEMENT9* layout, int count, IDirect3DVertexDeclaration9** il);
HRESULT CompileShader(UINT id, const string& entry, const D3DXMACRO* macro, IDirect3DPixelShader9** ps); HRESULT CompileShader(uint32 id, const string& entry, const D3DXMACRO* macro, IDirect3DPixelShader9** ps);
virtual bool IsCurrentRGBA() virtual bool IsCurrentRGBA()
{ {

6
plugins/GSdx/GSDeviceNull.h
View File

@ -40,14 +40,14 @@ public:
bool Create(HWND hWnd, bool vsync); bool Create(HWND hWnd, bool vsync);
bool Reset(int w, int h, bool fs); bool Reset(int w, int h, bool fs);
bool IsLost() {return false;} bool IsLost() {return false;}
void Present(const CRect& r) {} void Present(const GSVector4i& r) {}
void BeginScene() {} void BeginScene() {}
void EndScene() {} void EndScene() {}
void Draw(const string& s) {} void Draw(const string& s) {}
bool CopyOffscreen(Texture& src, const GSVector4& sr, Texture& dst, int w, int h, int format = 0) {return false;} bool CopyOffscreen(Texture& src, const GSVector4& sr, Texture& dst, int w, int h, int format = 0) {return false;}
void ClearRenderTarget(Texture& t, const GSVector4& c) {} void ClearRenderTarget(Texture& t, const GSVector4& c) {}
void ClearRenderTarget(Texture& t, DWORD c) {} void ClearRenderTarget(Texture& t, uint32 c) {}
void ClearDepth(Texture& t, float c) {} void ClearDepth(Texture& t, float c) {}
void ClearStencil(Texture& t, BYTE c) {} void ClearStencil(Texture& t, uint8 c) {}
}; };

67
plugins/GSdx/GSDirtyRect.cpp
View File

@ -23,36 +23,41 @@
#include "GSDirtyRect.h" #include "GSDirtyRect.h"
GSDirtyRect::GSDirtyRect() GSDirtyRect::GSDirtyRect()
: m_psm(PSM_PSMCT32) : psm(PSM_PSMCT32)
, m_rect(0, 0, 0, 0)
{ {
left = top = right = bottom = 0;
} }
GSDirtyRect::GSDirtyRect(DWORD psm, CRect rect) GSDirtyRect::GSDirtyRect(const GSVector4i& r, uint32 psm)
: psm(psm)
{ {
m_psm = psm; left = r.left;
m_rect = rect; top = r.top;
right = r.right;
bottom = r.bottom;
} }
CRect GSDirtyRect::GetDirtyRect(const GIFRegTEX0& TEX0) GSVector4i GSDirtyRect::GetDirtyRect(const GIFRegTEX0& TEX0)
{ {
CRect r = m_rect; GSVector4i r;
CSize src = GSLocalMemory::m_psm[m_psm].bs; GSVector2i src = GSLocalMemory::m_psm[psm].bs;
r.left = (r.left) & ~(src.cx-1); if(psm != TEX0.PSM)
r.right = (r.right + (src.cx-1) /* + 1 */) & ~(src.cx-1);
r.top = (r.top) & ~(src.cy-1);
r.bottom = (r.bottom + (src.cy-1) /* + 1 */) & ~(src.cy-1);
if(m_psm != TEX0.PSM)
{ {
CSize dst = GSLocalMemory::m_psm[TEX0.PSM].bs; GSVector2i dst = GSLocalMemory::m_psm[TEX0.PSM].bs;
r.left = MulDiv(m_rect.left, dst.cx, src.cx); r.left = MulDiv(left, dst.x, src.x);
r.right = MulDiv(m_rect.right, dst.cx, src.cx); r.right = MulDiv(right, dst.x, src.x);
r.top = MulDiv(m_rect.top, dst.cy, src.cy); r.top = MulDiv(top, dst.y, src.y);
r.bottom = MulDiv(m_rect.bottom, dst.cy, src.cy); r.bottom = MulDiv(bottom, dst.y, src.y);
}
else
{
r.left = left & ~(src.x - 1);
r.right = (right + (src.x - 1) /* + 1 */) & ~(src.x - 1);
r.top = top & ~(src.y - 1);
r.bottom = (bottom + (src.y - 1) /* + 1 */) & ~(src.y - 1);
} }
return r; return r;
@ -60,19 +65,21 @@ CRect GSDirtyRect::GetDirtyRect(const GIFRegTEX0& TEX0)
// //
CRect GSDirtyRectList::GetDirtyRect(const GIFRegTEX0& TEX0, CSize size) GSVector4i GSDirtyRectList::GetDirtyRectAndClear(const GIFRegTEX0& TEX0, const GSVector2i& size)
{ {
if(empty()) if(!empty())
{ {
return CRect(0, 0, 0, 0); GSVector4i r(INT_MAX, INT_MAX, 0, 0);
for(list<GSDirtyRect>::iterator i = begin(); i != end(); i++)
{
r = r.runion(i->GetDirtyRect(TEX0));
}
clear();
return r.rintersect(GSVector4i(0, 0, size.x, size.y));
} }
CRect r(INT_MAX, INT_MAX, 0, 0); return GSVector4i::zero();
for(list<GSDirtyRect>::iterator i = begin(); i != end(); i++)
{
r |= i->GetDirtyRect(TEX0);
}
return r & CRect(0, 0, size.cx, size.cy);
} }

14
plugins/GSdx/GSDirtyRect.h
View File

@ -25,18 +25,22 @@
class GSDirtyRect class GSDirtyRect
{ {
DWORD m_psm; int left;
CRect m_rect; int top;
int right;
int bottom;
uint32 psm;
public: public:
GSDirtyRect(); GSDirtyRect();
GSDirtyRect(DWORD psm, CRect rect); GSDirtyRect(const GSVector4i& r, uint32 psm);
CRect GetDirtyRect(const GIFRegTEX0& TEX0); GSVector4i GetDirtyRect(const GIFRegTEX0& TEX0);
}; };
class GSDirtyRectList : public list<GSDirtyRect> class GSDirtyRectList : public list<GSDirtyRect>
{ {
public: public:
GSDirtyRectList() {} GSDirtyRectList() {}
CRect GetDirtyRect(const GIFRegTEX0& TEX0, CSize size); GSVector4i GetDirtyRectAndClear(const GIFRegTEX0& TEX0, const GSVector2i& size);
}; };

40
plugins/GSdx/GSDrawScanline.cpp
View File

@ -56,8 +56,8 @@ void GSDrawScanline::BeginDraw(const GSRasterizerData* data, Functions* f)
m_env.zm = GSVector4i(p->zm); m_env.zm = GSVector4i(p->zm);
m_env.aref = GSVector4i((int)context->TEST.AREF); m_env.aref = GSVector4i((int)context->TEST.AREF);
m_env.afix = GSVector4i((int)context->ALPHA.FIX << 7).xxzzlh(); m_env.afix = GSVector4i((int)context->ALPHA.FIX << 7).xxzzlh();
m_env.frb = GSVector4i((int)env.FOGCOL.ai32[0] & 0x00ff00ff); m_env.frb = GSVector4i((int)env.FOGCOL.u32[0] & 0x00ff00ff);
m_env.fga = GSVector4i((int)(env.FOGCOL.ai32[0] >> 8) & 0x00ff00ff); m_env.fga = GSVector4i((int)(env.FOGCOL.u32[0] >> 8) & 0x00ff00ff);
m_env.dimx = env.dimx; m_env.dimx = env.dimx;
if(m_sel.fpsm == 1) if(m_sel.fpsm == 1)
@ -212,34 +212,34 @@ void GSDrawScanline::DrawSolidRect(const GSVector4i& r, const GSVertexSW& v)
// FIXME: sometimes the frame and z buffer may overlap, the outcome is undefined // FIXME: sometimes the frame and z buffer may overlap, the outcome is undefined
DWORD m; uint32 m;
m = m_env.zm.u32[0]; m = m_env.zm.u32[0];
if(m != 0xffffffff) if(m != 0xffffffff)
{ {
DWORD z = (DWORD)(float)v.p.z; uint32 z = (uint32)v.p.z;
if(m_sel.zpsm != 2) if(m_sel.zpsm != 2)
{ {
if(m == 0) if(m == 0)
{ {
DrawSolidRectT<DWORD, false>(m_env.zbr, m_env.zbc[0], r, z, m); DrawSolidRectT<uint32, false>(m_env.zbr, m_env.zbc[0], r, z, m);
} }
else else
{ {
DrawSolidRectT<DWORD, true>(m_env.zbr, m_env.zbc[0], r, z, m); DrawSolidRectT<uint32, true>(m_env.zbr, m_env.zbc[0], r, z, m);
} }
} }
else else
{ {
if(m == 0) if(m == 0)
{ {
DrawSolidRectT<WORD, false>(m_env.zbr, m_env.zbc[0], r, z, m); DrawSolidRectT<uint16, false>(m_env.zbr, m_env.zbc[0], r, z, m);
} }
else else
{ {
DrawSolidRectT<WORD, true>(m_env.zbr, m_env.zbc[0], r, z, m); DrawSolidRectT<uint16, true>(m_env.zbr, m_env.zbc[0], r, z, m);
} }
} }
} }
@ -248,7 +248,7 @@ void GSDrawScanline::DrawSolidRect(const GSVector4i& r, const GSVertexSW& v)
if(m != 0xffffffff) if(m != 0xffffffff)
{ {
DWORD c = (GSVector4i(v.c) >> 7).rgba32(); uint32 c = (GSVector4i(v.c) >> 7).rgba32();
if(m_state->m_context->FBA.FBA) if(m_state->m_context->FBA.FBA)
{ {
@ -259,11 +259,11 @@ void GSDrawScanline::DrawSolidRect(const GSVector4i& r, const GSVertexSW& v)
{ {
if(m == 0) if(m == 0)
{ {
DrawSolidRectT<DWORD, false>(m_env.fbr, m_env.fbc[0], r, c, m); DrawSolidRectT<uint32, false>(m_env.fbr, m_env.fbc[0], r, c, m);
} }
else else
{ {
DrawSolidRectT<DWORD, true>(m_env.fbr, m_env.fbc[0], r, c, m); DrawSolidRectT<uint32, true>(m_env.fbr, m_env.fbc[0], r, c, m);
} }
} }
else else
@ -272,25 +272,25 @@ void GSDrawScanline::DrawSolidRect(const GSVector4i& r, const GSVertexSW& v)
if(m == 0) if(m == 0)
{ {
DrawSolidRectT<WORD, false>(m_env.fbr, m_env.fbc[0], r, c, m); DrawSolidRectT<uint16, false>(m_env.fbr, m_env.fbc[0], r, c, m);
} }
else else
{ {
DrawSolidRectT<WORD, true>(m_env.fbr, m_env.fbc[0], r, c, m); DrawSolidRectT<uint16, true>(m_env.fbr, m_env.fbc[0], r, c, m);
} }
} }
} }
} }
template<class T, bool masked> template<class T, bool masked>
void GSDrawScanline::DrawSolidRectT(const GSVector4i* row, int* col, const GSVector4i& r, DWORD c, DWORD m) void GSDrawScanline::DrawSolidRectT(const GSVector4i* row, int* col, const GSVector4i& r, uint32 c, uint32 m)
{ {
if(m == 0xffffffff) return; if(m == 0xffffffff) return;
GSVector4i color((int)c); GSVector4i color((int)c);
GSVector4i mask((int)m); GSVector4i mask((int)m);
if(sizeof(T) == sizeof(WORD)) if(sizeof(T) == sizeof(uint16))
{ {
color = color.xxzzlh(); color = color.xxzzlh();
mask = mask.xxzzlh(); mask = mask.xxzzlh();
@ -314,13 +314,13 @@ void GSDrawScanline::DrawSolidRectT(const GSVector4i* row, int* col, const GSVec
} }
template<class T, bool masked> template<class T, bool masked>
void GSDrawScanline::FillRect(const GSVector4i* row, int* col, const GSVector4i& r, DWORD c, DWORD m) void GSDrawScanline::FillRect(const GSVector4i* row, int* col, const GSVector4i& r, uint32 c, uint32 m)
{ {
if(r.x >= r.z) return; if(r.x >= r.z) return;
for(int y = r.y; y < r.w; y++) for(int y = r.y; y < r.w; y++)
{ {
DWORD base = row[y].x; uint32 base = row[y].x;
for(int x = r.x; x < r.z; x++) for(int x = r.x; x < r.z; x++)
{ {
@ -338,7 +338,7 @@ void GSDrawScanline::FillBlock(const GSVector4i* row, int* col, const GSVector4i
for(int y = r.y; y < r.w; y += 8) for(int y = r.y; y < r.w; y += 8)
{ {
DWORD base = row[y].x; uint32 base = row[y].x;
for(int x = r.x; x < r.z; x += 8 * 4 / sizeof(T)) for(int x = r.x; x < r.z; x += 8 * 4 / sizeof(T))
{ {
@ -363,7 +363,7 @@ GSDrawScanline::GSSetupPrimMap::GSSetupPrimMap(GSScanlineEnvironment& env)
{ {
} }
GSSetupPrimCodeGenerator* GSDrawScanline::GSSetupPrimMap::Create(UINT64 key, void* ptr, size_t maxsize) GSSetupPrimCodeGenerator* GSDrawScanline::GSSetupPrimMap::Create(uint64 key, void* ptr, size_t maxsize)
{ {
return new GSSetupPrimCodeGenerator(m_env, key, ptr, maxsize); return new GSSetupPrimCodeGenerator(m_env, key, ptr, maxsize);
} }
@ -376,7 +376,7 @@ GSDrawScanline::GSDrawScanlineMap::GSDrawScanlineMap(GSScanlineEnvironment& env)
{ {
} }
GSDrawScanlineCodeGenerator* GSDrawScanline::GSDrawScanlineMap::Create(UINT64 key, void* ptr, size_t maxsize) GSDrawScanlineCodeGenerator* GSDrawScanline::GSDrawScanlineMap::Create(uint64 key, void* ptr, size_t maxsize)
{ {
return new GSDrawScanlineCodeGenerator(m_env, key, ptr, maxsize); return new GSDrawScanlineCodeGenerator(m_env, key, ptr, maxsize);
} }

12
plugins/GSdx/GSDrawScanline.h
View File

@ -35,24 +35,24 @@ class GSDrawScanline : public GSAlignedClass<16>, public IDrawScanline
// //
class GSSetupPrimMap : public GSCodeGeneratorFunctionMap<GSSetupPrimCodeGenerator, UINT64, SetupPrimStaticPtr> class GSSetupPrimMap : public GSCodeGeneratorFunctionMap<GSSetupPrimCodeGenerator, uint64, SetupPrimStaticPtr>
{ {
GSScanlineEnvironment& m_env; GSScanlineEnvironment& m_env;
public: public:
GSSetupPrimMap(GSScanlineEnvironment& env); GSSetupPrimMap(GSScanlineEnvironment& env);
GSSetupPrimCodeGenerator* Create(UINT64 key, void* ptr, size_t maxsize); GSSetupPrimCodeGenerator* Create(uint64 key, void* ptr, size_t maxsize);
} m_sp; } m_sp;
// //
class GSDrawScanlineMap : public GSCodeGeneratorFunctionMap<GSDrawScanlineCodeGenerator, UINT64, DrawScanlineStaticPtr> class GSDrawScanlineMap : public GSCodeGeneratorFunctionMap<GSDrawScanlineCodeGenerator, uint64, DrawScanlineStaticPtr>
{ {
GSScanlineEnvironment& m_env; GSScanlineEnvironment& m_env;
public: public:
GSDrawScanlineMap(GSScanlineEnvironment& env); GSDrawScanlineMap(GSScanlineEnvironment& env);
GSDrawScanlineCodeGenerator* Create(UINT64 key, void* ptr, size_t maxsize); GSDrawScanlineCodeGenerator* Create(uint64 key, void* ptr, size_t maxsize);
} m_ds; } m_ds;
// //
@ -60,10 +60,10 @@ class GSDrawScanline : public GSAlignedClass<16>, public IDrawScanline
void DrawSolidRect(const GSVector4i& r, const GSVertexSW& v); void DrawSolidRect(const GSVector4i& r, const GSVertexSW& v);
template<class T, bool masked> template<class T, bool masked>
void DrawSolidRectT(const GSVector4i* row, int* col, const GSVector4i& r, DWORD c, DWORD m); void DrawSolidRectT(const GSVector4i* row, int* col, const GSVector4i& r, uint32 c, uint32 m);
template<class T, bool masked> template<class T, bool masked>
__forceinline void FillRect(const GSVector4i* row, int* col, const GSVector4i& r, DWORD c, DWORD m); __forceinline void FillRect(const GSVector4i* row, int* col, const GSVector4i& r, uint32 c, uint32 m);
template<class T, bool masked> template<class T, bool masked>
__forceinline void FillBlock(const GSVector4i* row, int* col, const GSVector4i& r, const GSVector4i& c, const GSVector4i& m); __forceinline void FillBlock(const GSVector4i* row, int* col, const GSVector4i& r, const GSVector4i& c, const GSVector4i& m);

10
plugins/GSdx/GSDrawScanlineCodeGenerator.cpp
View File

@ -875,10 +875,10 @@ void GSDrawScanlineCodeGenerator::SampleTexture()
// xmm1, xmm4, xmm6 = free // xmm1, xmm4, xmm6 = free
// xmm7 = used // xmm7 = used
// c00 = addr00.gather32_32((const DWORD/BYTE*)tex[, clut]); // c00 = addr00.gather32_32((const uint32/uint8*)tex[, clut]);
// c01 = addr01.gather32_32((const DWORD/BYTE*)tex[, clut]); // c01 = addr01.gather32_32((const uint32/uint8*)tex[, clut]);
// c10 = addr10.gather32_32((const DWORD/BYTE*)tex[, clut]); // c10 = addr10.gather32_32((const uint32/uint8*)tex[, clut]);
// c11 = addr11.gather32_32((const DWORD/BYTE*)tex[, clut]); // c11 = addr11.gather32_32((const uint32/uint8*)tex[, clut]);
ReadTexel(xmm6, xmm5, xmm1, xmm4); ReadTexel(xmm6, xmm5, xmm1, xmm4);
@ -994,7 +994,7 @@ void GSDrawScanlineCodeGenerator::SampleTexture()
paddd(xmm2, xmm4); paddd(xmm2, xmm4);
// c00 = addr00.gather32_32((const DWORD/BYTE*)tex[, clut]); // c00 = addr00.gather32_32((const uint32/uint8*)tex[, clut]);
ReadTexel(xmm5, xmm2, xmm0, xmm1); ReadTexel(xmm5, xmm2, xmm0, xmm1);

6
plugins/GSdx/GSDump.cpp
View File

@ -36,7 +36,7 @@ GSDump::~GSDump()
Close(); Close();
} }
void GSDump::Open(const string& fn, DWORD crc, const GSFreezeData& fd, const GSPrivRegSet* regs) void GSDump::Open(const string& fn, uint32 crc, const GSFreezeData& fd, const GSPrivRegSet* regs)
{ {
m_gs = fopen((fn + ".gs").c_str(), "wb"); m_gs = fopen((fn + ".gs").c_str(), "wb");
m_obj = fopen((fn + ".obj").c_str(), "wt"); m_obj = fopen((fn + ".obj").c_str(), "wt");
@ -60,7 +60,7 @@ void GSDump::Close()
if(m_obj) {fclose(m_obj); m_obj = NULL;} if(m_obj) {fclose(m_obj); m_obj = NULL;}
} }
void GSDump::Transfer(int index, BYTE* mem, size_t size) void GSDump::Transfer(int index, uint8* mem, size_t size)
{ {
if(m_gs && size > 0) if(m_gs && size > 0)
{ {
@ -71,7 +71,7 @@ void GSDump::Transfer(int index, BYTE* mem, size_t size)
} }
} }
void GSDump::ReadFIFO(UINT32 size) void GSDump::ReadFIFO(uint32 size)
{ {
if(m_gs && size > 0) if(m_gs && size > 0)
{ {

6
plugins/GSdx/GSDump.h
View File

@ -55,10 +55,10 @@ public:
GSDump(); GSDump();
virtual ~GSDump(); virtual ~GSDump();
void Open(const string& fn, DWORD crc, const GSFreezeData& fd, const GSPrivRegSet* regs); void Open(const string& fn, uint32 crc, const GSFreezeData& fd, const GSPrivRegSet* regs);
void Close(); void Close();
void ReadFIFO(UINT32 size); void ReadFIFO(uint32 size);
void Transfer(int index, BYTE* mem, size_t size); void Transfer(int index, uint8* mem, size_t size);
void VSync(int field, bool last, const GSPrivRegSet* regs); void VSync(int field, bool last, const GSPrivRegSet* regs);
void Object(GSVertexSW* vertices, int count, GS_PRIM_CLASS primclass); void Object(GSVertexSW* vertices, int count, GS_PRIM_CLASS primclass);
operator bool() {return m_gs != NULL;} operator bool() {return m_gs != NULL;}

8
plugins/GSdx/GSFunctionMap.h
View File

@ -158,9 +158,9 @@ public:
template<class CG, class KEY, class VALUE> template<class CG, class KEY, class VALUE>
class GSCodeGeneratorFunctionMap : public GSFunctionMap<KEY, VALUE> class GSCodeGeneratorFunctionMap : public GSFunctionMap<KEY, VALUE>
{ {
DWORD m_id; uint32 m_id;
string m_name; string m_name;
hash_map<UINT64, CG*> m_cgmap; hash_map<uint64, CG*> m_cgmap;
GSCodeBuffer m_cb; GSCodeBuffer m_cb;
enum {MAX_SIZE = 4096}; enum {MAX_SIZE = 4096};
@ -177,7 +177,7 @@ public:
virtual ~GSCodeGeneratorFunctionMap() virtual ~GSCodeGeneratorFunctionMap()
{ {
for(hash_map<UINT64, CG*>::iterator i = m_cgmap.begin(); i != m_cgmap.end(); i++) for(hash_map<uint64, CG*>::iterator i = m_cgmap.begin(); i != m_cgmap.end(); i++)
{ {
delete (*i).second; delete (*i).second;
} }
@ -207,7 +207,7 @@ public:
// vtune method registration // vtune method registration
string name = format("%s<%016I64x>()", m_name.c_str(), (UINT64)key); string name = format("%s<%016I64x>()", m_name.c_str(), (uint64)key);
iJIT_Method_Load ml; iJIT_Method_Load ml;

591
plugins/GSdx/GSLocalMemory.cpp
View File

File diff suppressed because it is too large Load Diff

486
plugins/GSdx/GSLocalMemory.h
View File

File diff suppressed because it is too large Load Diff

79
plugins/GSdx/GSRasterizer.cpp
View File

@ -94,7 +94,7 @@ void GSRasterizer::DrawPoint(const GSVertexSW* v, const GSVector4i& scissor)
GSVector4i p(v->p); GSVector4i p(v->p);
if(scissor.x <= p.x && p.x < scissor.z && scissor.y <= p.y && p.y < scissor.w) if(scissor.left <= p.x && p.x < scissor.right && scissor.top <= p.y && p.y < scissor.bottom)
{ {
if((p.y % m_threads) == m_id) if((p.y % m_threads) == m_id)
{ {
@ -153,7 +153,7 @@ void GSRasterizer::DrawLine(const GSVertexSW* v, const GSVector4i& scissor)
GSVector4i p(l.p); GSVector4i p(l.p);
if(scissor.y <= p.y && p.y < scissor.w) if(scissor.top <= p.y && p.y < scissor.bottom)
{ {
GSVertexSW dscan = dv / dv.p.xxxx(); GSVertexSW dscan = dv / dv.p.xxxx();
@ -546,29 +546,9 @@ void GSRasterizer::DrawSprite(const GSVertexSW* vertices, const GSVector4i& scis
GSVector4i r(v[0].p.xyxy(v[1].p).ceil()); GSVector4i r(v[0].p.xyxy(v[1].p).ceil());
int& top = r.y; r = r.rintersect(scissor);
int& bottom = r.w;
int& left = r.x; if(r.rempty()) return;
int& right = r.z;
#if _M_SSE >= 0x401
r = r.sat_i32(scissor);
if((r < r.zwzw()).mask() != 0x00ff) return;
#else
if(top < scissor.y) top = scissor.y;
if(bottom > scissor.w) bottom = scissor.w;
if(top >= bottom) return;
if(left < scissor.x) left = scissor.x;
if(right > scissor.z) right = scissor.z;
if(left >= right) return;
#endif
GSVertexSW scan = v[0]; GSVertexSW scan = v[0];
@ -578,7 +558,7 @@ void GSRasterizer::DrawSprite(const GSVertexSW* vertices, const GSVector4i& scis
{ {
(m_ds->*m_dsf.sr)(r, scan); (m_ds->*m_dsf.sr)(r, scan);
m_stats.pixels += (r.z - r.x) * (r.w - r.y); m_stats.pixels += r.width() * r.height();
} }
return; return;
@ -599,18 +579,18 @@ void GSRasterizer::DrawSprite(const GSVertexSW* vertices, const GSVector4i& scis
dedge.t = (dv.t / dv.p.yyyy()).xyxy(zero).wyww(); dedge.t = (dv.t / dv.p.yyyy()).xyxy(zero).wyww();
dscan.t = (dv.t / dv.p.xxxx()).xyxy(zero).xwww(); dscan.t = (dv.t / dv.p.xxxx()).xyxy(zero).xwww();
if(scan.p.y < (float)top) scan.t += dedge.t * ((float)top - scan.p.y); if(scan.p.y < (float)r.top) scan.t += dedge.t * ((float)r.top - scan.p.y);
if(scan.p.x < (float)left) scan.t += dscan.t * ((float)left - scan.p.x); if(scan.p.x < (float)r.left) scan.t += dscan.t * ((float)r.left - scan.p.x);
m_dsf.ssp(v, dscan); m_dsf.ssp(v, dscan);
for(; top < bottom; top++, scan.t += dedge.t) for(; r.top < r.bottom; r.top++, scan.t += dedge.t)
{ {
if((top % m_threads) == m_id) if((r.top % m_threads) == m_id)
{ {
m_dsf.ssl(right, left, top, scan); m_dsf.ssl(r.right, r.left, r.top, scan);
m_stats.pixels += right - left; m_stats.pixels += r.width();
} }
} }
} }
@ -681,7 +661,7 @@ void GSRasterizer::DrawEdge(const GSVertexSW& v0, const GSVertexSW& v1, const GS
int xi = x >> 16; int xi = x >> 16;
int xf = x & 0xffff; int xf = x & 0xffff;
if(scissor.x <= xi && xi < scissor.z && (xi % m_threads) == m_id) if(scissor.left <= xi && xi < scissor.right && (xi % m_threads) == m_id)
{ {
m_stats.pixels++; m_stats.pixels++;
@ -709,7 +689,7 @@ void GSRasterizer::DrawEdge(const GSVertexSW& v0, const GSVertexSW& v1, const GS
int xi = (x >> 16) + 1; int xi = (x >> 16) + 1;
int xf = x & 0xffff; int xf = x & 0xffff;
if(scissor.x <= xi && xi < scissor.z && (xi % m_threads) == m_id) if(scissor.left <= xi && xi < scissor.right && (xi % m_threads) == m_id)
{ {
m_stats.pixels++; m_stats.pixels++;
@ -779,7 +759,7 @@ void GSRasterizer::DrawEdge(const GSVertexSW& v0, const GSVertexSW& v1, const GS
int yi = y >> 16; int yi = y >> 16;
int yf = y & 0xffff; int yf = y & 0xffff;
if(scissor.y <= yi && yi < scissor.w && (yi % m_threads) == m_id) if(scissor.top <= yi && yi < scissor.bottom && (yi % m_threads) == m_id)
{ {
m_stats.pixels++; m_stats.pixels++;
@ -807,7 +787,7 @@ void GSRasterizer::DrawEdge(const GSVertexSW& v0, const GSVertexSW& v1, const GS
int yi = (y >> 16) + 1; int yi = (y >> 16) + 1;
int yf = y & 0xffff; int yf = y & 0xffff;
if(scissor.y <= yi && yi < scissor.w && (yi % m_threads) == m_id) if(scissor.top <= yi && yi < scissor.bottom && (yi % m_threads) == m_id)
{ {
m_stats.pixels++; m_stats.pixels++;
@ -835,29 +815,17 @@ GSRasterizerMT::GSRasterizerMT(IDrawScanline* ds, int id, int threads, long* syn
: GSRasterizer(ds, id, threads) : GSRasterizer(ds, id, threads)
, m_sync(sync) , m_sync(sync)
, m_exit(false) , m_exit(false)
, m_ThreadId(0)
, m_hThread(NULL)
, m_data(NULL) , m_data(NULL)
{ {
if(id > 0) if(id > 0)
{ {
m_hThread = CreateThread(NULL, 0, StaticThreadProc, (LPVOID)this, 0, &m_ThreadId); CreateThread();
} }
} }
GSRasterizerMT::~GSRasterizerMT() GSRasterizerMT::~GSRasterizerMT()
{ {
if(m_hThread != NULL) m_exit = true;
{
m_exit = true;
if(WaitForSingleObject(m_hThread, 5000) != WAIT_OBJECT_0)
{
TerminateThread(m_hThread, 1);
}
CloseHandle(m_hThread);
}
} }
void GSRasterizerMT::Draw(const GSRasterizerData* data) void GSRasterizerMT::Draw(const GSRasterizerData* data)
@ -870,16 +838,11 @@ void GSRasterizerMT::Draw(const GSRasterizerData* data)
{ {
m_data = data; m_data = data;
InterlockedBitTestAndSet(m_sync, m_id); _interlockedbittestandset(m_sync, m_id);
} }
} }
DWORD WINAPI GSRasterizerMT::StaticThreadProc(LPVOID lpParam) void GSRasterizerMT::ThreadProc()
{
return ((GSRasterizerMT*)lpParam)->ThreadProc();
}
DWORD GSRasterizerMT::ThreadProc()
{ {
// _mm_setcsr(MXCSR); // _mm_setcsr(MXCSR);
@ -889,15 +852,13 @@ DWORD GSRasterizerMT::ThreadProc()
{ {
__super::Draw(m_data); __super::Draw(m_data);
InterlockedBitTestAndReset(m_sync, m_id); _interlockedbittestandreset(m_sync, m_id);
} }
else else
{ {
_mm_pause(); _mm_pause();
} }
} }
return 0;
} }
// //

9
plugins/GSdx/GSRasterizer.h
View File

@ -24,6 +24,7 @@
#include "GS.h" #include "GS.h"
#include "GSVertexSW.h" #include "GSVertexSW.h"
#include "GSFunctionMap.h" #include "GSFunctionMap.h"
#include "GSThread.h"
__declspec(align(16)) class GSRasterizerData __declspec(align(16)) class GSRasterizerData
{ {
@ -102,17 +103,13 @@ public:
void PrintStats() {m_ds->PrintStats();} void PrintStats() {m_ds->PrintStats();}
}; };
class GSRasterizerMT : public GSRasterizer class GSRasterizerMT : public GSRasterizer, private GSThread
{ {
long* m_sync; long* m_sync;
bool m_exit; bool m_exit;
DWORD m_ThreadId;
HANDLE m_hThread;
const GSRasterizerData* m_data; const GSRasterizerData* m_data;
static DWORD WINAPI StaticThreadProc(LPVOID lpParam); void ThreadProc();
DWORD ThreadProc();
public: public:
GSRasterizerMT(IDrawScanline* ds, int id, int threads, long* sync); GSRasterizerMT(IDrawScanline* ds, int id, int threads, long* sync);

67
plugins/GSdx/GSRenderer.h
View File

@ -95,7 +95,7 @@ public:
GSWnd m_wnd; GSWnd m_wnd;
public: public:
GSRendererBase(BYTE* base, bool mt, void (*irq)(), const GSRendererSettings& rs) GSRendererBase(uint8* base, bool mt, void (*irq)(), const GSRendererSettings& rs)
: GSState(base, mt, irq) : GSState(base, mt, irq)
, m_osd(true) , m_osd(true)
{ {
@ -125,8 +125,8 @@ protected:
{ {
bool en[2]; bool en[2];
CRect fr[2]; GSVector4i fr[2];
CRect dr[2]; GSVector4i dr[2];
int baseline = INT_MAX; int baseline = INT_MAX;
@ -164,8 +164,8 @@ protected:
if(samesrc && m_regs->PMODE.SLBG == 0 && m_regs->PMODE.MMOD == 1 && m_regs->PMODE.ALP == 0x80) if(samesrc && m_regs->PMODE.SLBG == 0 && m_regs->PMODE.MMOD == 1 && m_regs->PMODE.ALP == 0x80)
{ {
if(fr[0] == fr[1] + CRect(0, 1, 0, 0) && dr[0] == dr[1] + CRect(0, 0, 0, 1) if(fr[0].eq(fr[1] + GSVector4i(0, 1, 0, 0)) && dr[0].eq(dr[1] + GSVector4i(0, 0, 0, 1))
|| fr[1] == fr[0] + CRect(0, 1, 0, 0) && dr[1] == dr[0] + CRect(0, 0, 0, 1)) || fr[1].eq(fr[0] + GSVector4i(0, 1, 0, 0)) && dr[1].eq(dr[0] + GSVector4i(0, 0, 0, 1)))
{ {
// persona 4: // persona 4:
// //
@ -195,7 +195,7 @@ protected:
blurdetected = true; blurdetected = true;
} }
else if(dr[0] == dr[1] && (fr[0] == fr[1] + CPoint(0, 1) || fr[1] == fr[0] + CPoint(0, 1))) else if(dr[0].eq(dr[1]) && (fr[0].eq(fr[1] + GSVector4i(0, 1, 0, 1)) || fr[1].eq(fr[0] + GSVector4i(0, 1, 0, 1))))
{ {
// dq5: // dq5:
// //
@ -214,8 +214,8 @@ protected:
} }
} }
CSize fs(0, 0); GSVector2i fs(0, 0);
CSize ds(0, 0); GSVector2i ds(0, 0);
Texture tex[2]; Texture tex[2];
@ -238,13 +238,13 @@ protected:
{ {
if(!en[i] || !tex[i]) continue; if(!en[i] || !tex[i]) continue;
CRect r = fr[i]; GSVector4i r = fr[i];
// overscan hack // overscan hack
if(dr[i].Height() > 512) // hmm if(dr[i].height() > 512) // hmm
{ {
int y = GetDeviceSize(i).cy; int y = GetDeviceRect(i).height();
if(m_regs->SMODE2.INT && m_regs->SMODE2.FFMD) y /= 2; if(m_regs->SMODE2.INT && m_regs->SMODE2.FFMD) y /= 2;
r.bottom = r.top + y; r.bottom = r.top + y;
} }
@ -280,17 +280,16 @@ protected:
dst[i].x = o.x; dst[i].x = o.x;
dst[i].y = o.y; dst[i].y = o.y;
dst[i].z = o.x + tex[i].m_scale.x * r.Width(); dst[i].z = o.x + tex[i].m_scale.x * r.width();
dst[i].w = o.y + tex[i].m_scale.y * r.Height(); dst[i].w = o.y + tex[i].m_scale.y * r.height();
fs.cx = max(fs.cx, (int)(dst[i].z + 0.5f)); fs.x = max(fs.x, (int)(dst[i].z + 0.5f));
fs.cy = max(fs.cy, (int)(dst[i].w + 0.5f)); fs.y = max(fs.y, (int)(dst[i].w + 0.5f));
} }
ds.cx = fs.cx; ds = fs;
ds.cy = fs.cy;
if(m_regs->SMODE2.INT && m_regs->SMODE2.FFMD) ds.cy *= 2; if(m_regs->SMODE2.INT && m_regs->SMODE2.FFMD) ds.y *= 2;
bool slbg = m_regs->PMODE.SLBG; bool slbg = m_regs->PMODE.SLBG;
bool mmod = m_regs->PMODE.MMOD; bool mmod = m_regs->PMODE.MMOD;
@ -331,7 +330,7 @@ protected:
fd.size = 0; fd.size = 0;
fd.data = NULL; fd.data = NULL;
Freeze(&fd, true); Freeze(&fd, true);
fd.data = new BYTE[fd.size]; fd.data = new uint8[fd.size];
Freeze(&fd, false); Freeze(&fd, false);
m_dump.Open(m_snapshot, m_crc, fd, m_regs); m_dump.Open(m_snapshot, m_crc, fd, m_regs);
@ -359,7 +358,7 @@ protected:
return; return;
} }
CSize size = m_capture.GetSize(); GSVector2i size = m_capture.GetSize();
Texture current; Texture current;
@ -367,9 +366,9 @@ protected:
Texture offscreen; Texture offscreen;
if(m_dev.CopyOffscreen(current, GSVector4(0, 0, 1, 1), offscreen, size.cx, size.cy)) if(m_dev.CopyOffscreen(current, GSVector4(0, 0, 1, 1), offscreen, size.x, size.y))
{ {
BYTE* bits = NULL; uint8* bits = NULL;
int pitch = 0; int pitch = 0;
if(offscreen.Map(&bits, pitch)) if(offscreen.Map(&bits, pitch))
@ -412,7 +411,7 @@ public:
GSCapture m_capture; GSCapture m_capture;
public: public:
GSRenderer(BYTE* base, bool mt, void (*irq)(), const GSRendererSettings& rs, bool psrr) GSRenderer(uint8* base, bool mt, void (*irq)(), const GSRendererSettings& rs, bool psrr)
: GSRendererBase(base, mt, irq, rs) : GSRendererBase(base, mt, irq, rs)
, m_psrr(psrr) , m_psrr(psrr)
{ {
@ -466,12 +465,14 @@ public:
double fps = 1000.0f / m_perfmon.Get(GSPerfMon::Frame); double fps = 1000.0f / m_perfmon.Get(GSPerfMon::Frame);
string interlace = m_regs->SMODE2.INT ? (string("Interlaced ") + (m_regs->SMODE2.FFMD ? "(frame)" : "(field)")) : "Progressive"; string s = m_regs->SMODE2.INT ? (string("Interlaced ") + (m_regs->SMODE2.FFMD ? "(frame)" : "(field)")) : "Progressive";
GSVector4i r = GetDisplayRect();
s_stats = format( s_stats = format(
"%I64d | %d x %d | %.2f fps (%d%%) | %s - %s | %s | %d/%d/%d | %d%% CPU | %.2f | %.2f", "%I64d | %d x %d | %.2f fps (%d%%) | %s - %s | %s | %d/%d/%d | %d%% CPU | %.2f | %.2f",
m_perfmon.GetFrame(), GetDisplaySize().cx, GetDisplaySize().cy, fps, (int)(100.0 * fps / GetFPS()), m_perfmon.GetFrame(), r.width(), r.height(), fps, (int)(100.0 * fps / GetFPS()),
interlace.c_str(), s.c_str(),
GSSettingsDlg::g_interlace[m_interlace].name, GSSettingsDlg::g_interlace[m_interlace].name,
GSSettingsDlg::g_aspectratio[m_aspectratio].name, GSSettingsDlg::g_aspectratio[m_aspectratio].name,
(int)m_perfmon.Get(GSPerfMon::Quad), (int)m_perfmon.Get(GSPerfMon::Quad),
@ -516,13 +517,11 @@ public:
// //
CRect r; GSVector4i r;
m_wnd.GetClientRect(&r); m_wnd.GetClientRect(r);
GSUtil::FitRect(r, m_aspectratio); m_dev.Present(r.fit(m_aspectratio));
m_dev.Present(r);
// //
@ -541,7 +540,7 @@ public:
return true; return true;
} }
virtual void MinMaxUV(int w, int h, CRect& r) {r = CRect(0, 0, w, h);} virtual void MinMaxUV(int w, int h, GSVector4i& r) {r = GSVector4i(0, 0, w, h);}
virtual bool CanUpscale() {return !m_nativeres;} virtual bool CanUpscale() {return !m_nativeres;}
}; };
@ -603,7 +602,7 @@ protected:
m_maxcount -= 100; m_maxcount -= 100;
} }
template<DWORD prim> __forceinline Vertex* DrawingKick(bool skip, DWORD& count) template<uint32 prim> __forceinline Vertex* DrawingKick(bool skip, int& count)
{ {
switch(prim) switch(prim)
{ {
@ -683,7 +682,7 @@ protected:
virtual void Draw() = 0; virtual void Draw() = 0;
public: public:
GSRendererT(BYTE* base, bool mt, void (*irq)(), const GSRendererSettings& rs, bool psrr = true) GSRendererT(uint8* base, bool mt, void (*irq)(), const GSRendererSettings& rs, bool psrr = true)
: GSRenderer<Device>(base, mt, irq, rs, psrr) : GSRenderer<Device>(base, mt, irq, rs, psrr)
, m_count(0) , m_count(0)
, m_maxcount(0) , m_maxcount(0)

71
plugins/GSdx/GSRendererHW.h
View File

@ -45,7 +45,7 @@ protected:
__super::Reset(); __super::Reset();
} }
void MinMaxUV(int w, int h, CRect& r) void MinMaxUV(int w, int h, GSVector4i& r)
{ {
int wms = m_context->CLAMP.WMS; int wms = m_context->CLAMP.WMS;
int wmt = m_context->CLAMP.WMT; int wmt = m_context->CLAMP.WMT;
@ -208,18 +208,15 @@ protected:
__assume(0); __assume(0);
} }
r = vr; r = vr + GSVector4i(-1, -1, 1, 1); // one more pixel because of bilinear filtering
r.InflateRect(1, 1); // one more pixel because of bilinear filtering GSVector2i bs = GSLocalMemory::m_psm[m_context->TEX0.PSM].bs;
GSVector2i bsm(bs.x - 1, bs.y - 1);
CSize bs = GSLocalMemory::m_psm[m_context->TEX0.PSM].bs; r.left = max(r.left & ~bsm.x, 0);
CSize bsm(bs.cx - 1, bs.cy - 1); r.top = max(r.top & ~bsm.y, 0);
r.right = min((r.right + bsm.x) & ~bsm.x, w);
r.left = max(r.left & ~bsm.cx, 0); r.bottom = min((r.bottom + bsm.y) & ~bsm.y, h);
r.right = min((r.right + bsm.cx) & ~bsm.cx, w);
r.top = max(r.top & ~bsm.cy, 0);
r.bottom = min((r.bottom + bsm.cy) & ~bsm.cy, h);
} }
void VSync(int field) void VSync(int field)
@ -275,14 +272,14 @@ protected:
return false; return false;
} }
void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, CRect r) void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& r)
{ {
TRACE(_T("[%d] InvalidateVideoMem %d,%d - %d,%d %05x (%d)\n"), (int)m_perfmon.GetFrame(), r.left, r.top, r.right, r.bottom, (int)BITBLTBUF.DBP, (int)BITBLTBUF.DPSM); TRACE(_T("[%d] InvalidateVideoMem %d,%d - %d,%d %05x (%d)\n"), (int)m_perfmon.GetFrame(), r.left, r.top, r.right, r.bottom, (int)BITBLTBUF.DBP, (int)BITBLTBUF.DPSM);
m_tc->InvalidateVideoMem(BITBLTBUF, r); m_tc->InvalidateVideoMem(BITBLTBUF, r);
} }
void InvalidateLocalMem(const GIFRegBITBLTBUF& BITBLTBUF, CRect r) void InvalidateLocalMem(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& r)
{ {
TRACE(_T("[%d] InvalidateLocalMem %d,%d - %d,%d %05x (%d)\n"), (int)m_perfmon.GetFrame(), r.left, r.top, r.right, r.bottom, (int)BITBLTBUF.SBP, (int)BITBLTBUF.SPSM); TRACE(_T("[%d] InvalidateLocalMem %d,%d - %d,%d %05x (%d)\n"), (int)m_perfmon.GetFrame(), r.left, r.top, r.right, r.bottom, (int)BITBLTBUF.SBP, (int)BITBLTBUF.SPSM);
@ -410,18 +407,18 @@ protected:
if(m_game.title == CRC::FFXII && m_game.region == CRC::EU) if(m_game.title == CRC::FFXII && m_game.region == CRC::EU)
{ {
static DWORD* video = NULL; static uint32* video = NULL;
static bool ok = false; static bool ok = false;
if(prim == GS_POINTLIST && m_count >= 448*448 && m_count <= 448*512) if(prim == GS_POINTLIST && m_count >= 448 * 448 && m_count <= 448 * 512)
{ {
// incoming pixels are stored in columns, one column is 16x512, total res 448x512 or 448x454 // incoming pixels are stored in columns, one column is 16x512, total res 448x512 or 448x454
if(!video) video = new DWORD[512*512]; if(!video) video = new uint32[512 * 512];
for(int x = 0, i = 0, rows = m_count / 448; x < 448; x += 16) for(int x = 0, i = 0, rows = m_count / 448; x < 448; x += 16)
{ {
DWORD* dst = &video[x]; uint32* dst = &video[x];
for(int y = 0; y < rows; y++, dst += 512) for(int y = 0; y < rows; y++, dst += 512)
{ {
@ -436,7 +433,7 @@ protected:
return false; return false;
} }
else if(prim == GS_LINELIST && m_count == 512*2 && ok) else if(prim == GS_LINELIST && m_count == 512 * 2 && ok)
{ {
// normally, this step would copy the video onto screen with 512 texture mapped horizontal lines, // normally, this step would copy the video onto screen with 512 texture mapped horizontal lines,
// but we use the stored video data to create a new texture, and replace the lines with two triangles // but we use the stored video data to create a new texture, and replace the lines with two triangles
@ -445,7 +442,7 @@ protected:
m_dev.CreateTexture(*t, 512, 512); m_dev.CreateTexture(*t, 512, 512);
t->Update(CRect(0, 0, 448, 512), video, 512*4); t->Update(GSVector4i(0, 0, 448, 512), video, 512 * 4);
m_vertices[0] = m_vertices[0]; m_vertices[0] = m_vertices[0];
m_vertices[1] = m_vertices[1]; m_vertices[1] = m_vertices[1];
@ -467,9 +464,9 @@ protected:
if(m_game.title == CRC::FFX) if(m_game.title == CRC::FFX)
{ {
DWORD FBP = m_context->FRAME.Block(); uint32 FBP = m_context->FRAME.Block();
DWORD ZBP = m_context->ZBUF.Block(); uint32 ZBP = m_context->ZBUF.Block();
DWORD TBP = m_context->TEX0.TBP0; uint32 TBP = m_context->TEX0.TBP0;
if((FBP == 0x00d00 || FBP == 0x00000) && ZBP == 0x02100 && PRIM->TME && TBP == 0x01a00 && m_context->TEX0.PSM == PSM_PSMCT16S) if((FBP == 0x00d00 || FBP == 0x00000) && ZBP == 0x02100 && PRIM->TME && TBP == 0x01a00 && m_context->TEX0.PSM == PSM_PSMCT16S)
{ {
@ -504,8 +501,8 @@ protected:
{ {
if(prim == GS_POINTLIST && !PRIM->TME) if(prim == GS_POINTLIST && !PRIM->TME)
{ {
DWORD bp = m_context->FRAME.Block(); uint32 bp = m_context->FRAME.Block();
DWORD bw = m_context->FRAME.FBW; uint32 bw = m_context->FRAME.FBW;
if(bp >= 0x03f40 && (bp & 0x1f) == 0) if(bp >= 0x03f40 && (bp & 0x1f) == 0)
{ {
@ -551,9 +548,9 @@ protected:
if(m_game.title == CRC::GodOfWar2) if(m_game.title == CRC::GodOfWar2)
{ {
DWORD FBP = m_context->FRAME.Block(); uint32 FBP = m_context->FRAME.Block();
DWORD FBW = m_context->FRAME.FBW; uint32 FBW = m_context->FRAME.FBW;
DWORD FPSM = m_context->FRAME.PSM; uint32 FPSM = m_context->FRAME.PSM;
if((FBP == 0x00f00 || FBP == 0x00100) && FPSM == PSM_PSMZ24) // ntsc 0xf00, pal 0x100 if((FBP == 0x00f00 || FBP == 0x00100) && FPSM == PSM_PSMZ24) // ntsc 0xf00, pal 0x100
{ {
@ -585,8 +582,8 @@ protected:
if(m_game.title == CRC::DBZBT2) if(m_game.title == CRC::DBZBT2)
{ {
DWORD FBP = m_context->FRAME.Block(); uint32 FBP = m_context->FRAME.Block();
DWORD TBP0 = m_context->TEX0.TBP0; uint32 TBP0 = m_context->TEX0.TBP0;
if(PRIM->TME && (FBP == 0x03c00 && TBP0 == 0x03c80 || FBP == 0x03ac0 && TBP0 == 0x03b40)) if(PRIM->TME && (FBP == 0x03c00 && TBP0 == 0x03c80 || FBP == 0x03ac0 && TBP0 == 0x03b40))
{ {
@ -596,7 +593,7 @@ protected:
BITBLTBUF.SBW = 1; BITBLTBUF.SBW = 1;
BITBLTBUF.SPSM = PSM_PSMCT32; BITBLTBUF.SPSM = PSM_PSMCT32;
InvalidateLocalMem(BITBLTBUF, CRect(0, 0, 64, 64)); InvalidateLocalMem(BITBLTBUF, GSVector4i(0, 0, 64, 64));
} }
} }
@ -606,7 +603,7 @@ protected:
if(m_game.title == CRC::MajokkoALaMode2) if(m_game.title == CRC::MajokkoALaMode2)
{ {
DWORD FBP = m_context->FRAME.Block(); uint32 FBP = m_context->FRAME.Block();
if(!PRIM->TME && FBP == 0x03f40) if(!PRIM->TME && FBP == 0x03f40)
{ {
@ -616,7 +613,7 @@ protected:
BITBLTBUF.SBW = 1; BITBLTBUF.SBW = 1;
BITBLTBUF.SPSM = PSM_PSMCT32; BITBLTBUF.SPSM = PSM_PSMCT32;
InvalidateLocalMem(BITBLTBUF, CRect(0, 0, 16, 16)); InvalidateLocalMem(BITBLTBUF, GSVector4i(0, 0, 16, 16));
} }
} }
@ -629,7 +626,7 @@ protected:
if(m_game.title == CRC::DBZBT2) if(m_game.title == CRC::DBZBT2)
{ {
DWORD FBP = m_context->FRAME.Block(); uint32 FBP = m_context->FRAME.Block();
if(FBP == 0x03c00 || FBP == 0x03ac0) if(FBP == 0x03c00 || FBP == 0x03ac0)
{ {
@ -643,7 +640,7 @@ protected:
if(m_game.title == CRC::MajokkoALaMode2) if(m_game.title == CRC::MajokkoALaMode2)
{ {
DWORD FBP = m_context->FRAME.Block(); uint32 FBP = m_context->FRAME.Block();
if(FBP == 0x03f40) if(FBP == 0x03f40)
{ {
@ -657,7 +654,7 @@ protected:
if(m_game.title == CRC::TalesOfAbyss) if(m_game.title == CRC::TalesOfAbyss)
{ {
DWORD FBP = m_context->FRAME.Block(); uint32 FBP = m_context->FRAME.Block();
if(FBP == 0x036e0 || FBP == 0x03560 || FBP == 0x038e0) if(FBP == 0x036e0 || FBP == 0x03560 || FBP == 0x038e0)
{ {
@ -671,7 +668,7 @@ protected:
} }
public: public:
GSRendererHW(BYTE* base, bool mt, void (*irq)(), const GSRendererSettings& rs, bool psrr) GSRendererHW(uint8* base, bool mt, void (*irq)(), const GSRendererSettings& rs, bool psrr)
: GSRendererT<Device, Vertex>(base, mt, irq, rs, psrr) : GSRendererT<Device, Vertex>(base, mt, irq, rs, psrr)
, m_width(1024) , m_width(1024)
, m_height(1024) , m_height(1024)
@ -692,7 +689,7 @@ public:
delete m_tc; delete m_tc;
} }
void SetGameCRC(DWORD crc, int options) void SetGameCRC(uint32 crc, int options)
{ {
__super::SetGameCRC(crc, options); __super::SetGameCRC(crc, options);

12
plugins/GSdx/GSRendererHW10.cpp
View File

@ -24,7 +24,7 @@
#include "GSCrc.h" #include "GSCrc.h"
#include "resource.h" #include "resource.h"
GSRendererHW10::GSRendererHW10(BYTE* base, bool mt, void (*irq)(), const GSRendererSettings& rs) GSRendererHW10::GSRendererHW10(uint8* base, bool mt, void (*irq)(), const GSRendererSettings& rs)
: GSRendererHW<Device, Vertex, TextureCache>(base, mt, irq, rs, true) : GSRendererHW<Device, Vertex, TextureCache>(base, mt, irq, rs, true)
{ {
InitVertexKick<GSRendererHW10>(); InitVertexKick<GSRendererHW10>();
@ -70,7 +70,7 @@ bool GSRendererHW10::Create(const string& title)
return true; return true;
} }
template<DWORD prim, DWORD tme, DWORD fst> template<uint32 prim, uint32 tme, uint32 fst>
void GSRendererHW10::VertexKick(bool skip) void GSRendererHW10::VertexKick(bool skip)
{ {
Vertex& dst = m_vl.AddTail(); Vertex& dst = m_vl.AddTail();
@ -83,7 +83,7 @@ void GSRendererHW10::VertexKick(bool skip)
GSVector4::storel(&dst.ST, m_v.GetUV()); GSVector4::storel(&dst.ST, m_v.GetUV());
} }
DWORD count = 0; int count = 0;
if(Vertex* v = DrawingKick<prim>(skip, count)) if(Vertex* v = DrawingKick<prim>(skip, count))
{ {
@ -412,7 +412,7 @@ void GSRendererHW10::Draw(int prim, Texture& rt, Texture& ds, GSTextureCache<Dev
int w = rt.GetWidth(); int w = rt.GetWidth();
int h = rt.GetHeight(); int h = rt.GetHeight();
CRect scissor = (CRect)GSVector4i(GSVector4(rt.m_scale).xyxy() * context->scissor.in) & CRect(0, 0, w, h); GSVector4i scissor = GSVector4i(GSVector4(rt.m_scale).xyxy() * context->scissor.in).rintersect(GSVector4i(0, 0, w, h));
// //
@ -436,7 +436,7 @@ void GSRendererHW10::Draw(int prim, Texture& rt, Texture& ds, GSTextureCache<Dev
{ {
ASSERT(!env.PABE.PABE); ASSERT(!env.PABE.PABE);
static const DWORD iatst[] = {1, 0, 5, 6, 7, 2, 3, 4}; static const uint32 iatst[] = {1, 0, 5, 6, 7, 2, 3, 4};
ps_sel.atst = iatst[ps_sel.atst]; ps_sel.atst = iatst[ps_sel.atst];
@ -474,7 +474,7 @@ void GSRendererHW10::Draw(int prim, Texture& rt, Texture& ds, GSTextureCache<Dev
m_dev.EndScene(); m_dev.EndScene();
} }
bool GSRendererHW10::WrapZ(DWORD maxz) bool GSRendererHW10::WrapZ(uint32 maxz)
{ {
// should only run once if z values are in the z buffer range // should only run once if z values are in the z buffer range

6
plugins/GSdx/GSRendererHW10.h
View File

@ -32,7 +32,7 @@ class GSRendererHW10 : public GSRendererHW<GSDevice10, GSVertexHW10, GSTextureCa
typedef GSVertexHW10 Vertex; typedef GSVertexHW10 Vertex;
typedef GSTextureCache10 TextureCache; typedef GSTextureCache10 TextureCache;
bool WrapZ(DWORD maxz); bool WrapZ(uint32 maxz);
protected: protected:
GSTextureFX10 m_tfx; GSTextureFX10 m_tfx;
@ -48,9 +48,9 @@ protected:
void SetupDATE(Texture& rt, Texture& ds); void SetupDATE(Texture& rt, Texture& ds);
public: public:
GSRendererHW10(BYTE* base, bool mt, void (*irq)(), const GSRendererSettings& rs); GSRendererHW10(uint8* base, bool mt, void (*irq)(), const GSRendererSettings& rs);
bool Create(const string& title); bool Create(const string& title);
template<DWORD prim, DWORD tme, DWORD fst> void VertexKick(bool skip); template<uint32 prim, uint32 tme, uint32 fst> void VertexKick(bool skip);
}; };

16
plugins/GSdx/GSRendererHW9.cpp
View File

@ -24,7 +24,7 @@
#include "GSCrc.h" #include "GSCrc.h"
#include "resource.h" #include "resource.h"
GSRendererHW9::GSRendererHW9(BYTE* base, bool mt, void (*irq)(), const GSRendererSettings& rs) GSRendererHW9::GSRendererHW9(uint8* base, bool mt, void (*irq)(), const GSRendererSettings& rs)
: GSRendererHW<Device, Vertex, TextureCache>(base, mt, irq, rs, false) : GSRendererHW<Device, Vertex, TextureCache>(base, mt, irq, rs, false)
{ {
m_fba.enabled = !!AfxGetApp()->GetProfileInt(_T("Settings"), _T("fba"), TRUE); m_fba.enabled = !!AfxGetApp()->GetProfileInt(_T("Settings"), _T("fba"), TRUE);
@ -74,7 +74,7 @@ bool GSRendererHW9::Create(const string& title)
return true; return true;
} }
template<DWORD prim, DWORD tme, DWORD fst> template<uint32 prim, uint32 tme, uint32 fst>
void GSRendererHW9::VertexKick(bool skip) void GSRendererHW9::VertexKick(bool skip)
{ {
Vertex& dst = m_vl.AddTail(); Vertex& dst = m_vl.AddTail();
@ -83,8 +83,8 @@ void GSRendererHW9::VertexKick(bool skip)
dst.p.y = (float)(int)m_v.XYZ.Y; dst.p.y = (float)(int)m_v.XYZ.Y;
dst.p.z = (float)m_v.XYZ.Z; dst.p.z = (float)m_v.XYZ.Z;
dst.c0 = m_v.RGBAQ.ai32[0]; dst.c0 = m_v.RGBAQ.u32[0];
dst.c1 = m_v.FOG.ai32[1]; dst.c1 = m_v.FOG.u32[1];
if(tme) if(tme)
{ {
@ -100,7 +100,7 @@ void GSRendererHW9::VertexKick(bool skip)
} }
} }
DWORD count = 0; int count = 0;
if(Vertex* v = DrawingKick<prim>(skip, count)) if(Vertex* v = DrawingKick<prim>(skip, count))
{ {
@ -234,7 +234,7 @@ void GSRendererHW9::Draw(int prim, Texture& rt, Texture& ds, GSTextureCache<Devi
om_bsel.wb = (context->FRAME.FBMSK & 0x00ff0000) != 0x00ff0000; om_bsel.wb = (context->FRAME.FBMSK & 0x00ff0000) != 0x00ff0000;
om_bsel.wa = (context->FRAME.FBMSK & 0xff000000) != 0xff000000; om_bsel.wa = (context->FRAME.FBMSK & 0xff000000) != 0xff000000;
BYTE bf = context->ALPHA.FIX >= 0x80 ? 0xff : (BYTE)(context->ALPHA.FIX * 2); uint8 bf = context->ALPHA.FIX >= 0x80 ? 0xff : (uint8)(context->ALPHA.FIX * 2);
// vs // vs
@ -386,7 +386,7 @@ void GSRendererHW9::Draw(int prim, Texture& rt, Texture& ds, GSTextureCache<Devi
int w = rt.GetWidth(); int w = rt.GetWidth();
int h = rt.GetHeight(); int h = rt.GetHeight();
CRect scissor = (CRect)GSVector4i(GSVector4(rt.m_scale).xyxy() * context->scissor.in) & CRect(0, 0, w, h); GSVector4i scissor = GSVector4i(GSVector4(rt.m_scale).xyxy() * context->scissor.in).rintersect(GSVector4i(0, 0, w, h));
// //
@ -410,7 +410,7 @@ void GSRendererHW9::Draw(int prim, Texture& rt, Texture& ds, GSTextureCache<Devi
{ {
ASSERT(!env.PABE.PABE); ASSERT(!env.PABE.PABE);
static const DWORD iatst[] = {1, 0, 5, 6, 7, 2, 3, 4}; static const uint32 iatst[] = {1, 0, 5, 6, 7, 2, 3, 4};
ps_sel.atst = iatst[ps_sel.atst]; ps_sel.atst = iatst[ps_sel.atst];

4
plugins/GSdx/GSRendererHW9.h
View File

@ -57,9 +57,9 @@ protected:
void UpdateFBA(Texture& rt); void UpdateFBA(Texture& rt);
public: public:
GSRendererHW9(BYTE* base, bool mt, void (*irq)(), const GSRendererSettings& rs); GSRendererHW9(uint8* base, bool mt, void (*irq)(), const GSRendererSettings& rs);
bool Create(const string& title); bool Create(const string& title);
template<DWORD prim, DWORD tme, DWORD fst> void VertexKick(bool skip); template<uint32 prim, uint32 tme, uint32 fst> void VertexKick(bool skip);
}; };

4
plugins/GSdx/GSRendererNull.h
View File

@ -37,13 +37,13 @@ protected:
} }
public: public:
GSRendererNull(BYTE* base, bool mt, void (*irq)(), const GSRendererSettings& rs) GSRendererNull(uint8* base, bool mt, void (*irq)(), const GSRendererSettings& rs)
: GSRendererT<Device, GSVertexNull>(base, mt, irq, rs) : GSRendererT<Device, GSVertexNull>(base, mt, irq, rs)
{ {
InitVertexKick<GSRendererNull<Device> >(); InitVertexKick<GSRendererNull<Device> >();
} }
template<DWORD prim, DWORD tme, DWORD fst> void VertexKick(bool skip) template<uint32 prim, uint32 tme, uint32 fst> void VertexKick(bool skip)
{ {
} }
}; };

65
plugins/GSdx/GSRendererSW.h
View File

@ -79,16 +79,16 @@ protected:
TEX0.TBW = DISPFB.FBW; TEX0.TBW = DISPFB.FBW;
TEX0.PSM = DISPFB.PSM; TEX0.PSM = DISPFB.PSM;
CRect r(0, 0, TEX0.TBW * 64, GetFrameRect(i).bottom); GSVector4i r(0, 0, TEX0.TBW * 64, GetFrameRect(i).bottom);
// TODO: round up bottom // TODO: round up bottom
if(m_texture[i].GetWidth() != r.Width() || m_texture[i].GetHeight() != r.Height()) if(m_texture[i].GetWidth() != r.width() || m_texture[i].GetHeight() != r.height())
{ {
m_texture[i] = Texture(); m_texture[i] = Texture();
} }
if(!m_texture[i] && !m_dev.CreateTexture(m_texture[i], r.Width(), r.Height())) if(!m_texture[i] && !m_dev.CreateTexture(m_texture[i], r.width(), r.height()))
{ {
return false; return false;
} }
@ -98,7 +98,7 @@ protected:
CLAMP.WMS = CLAMP.WMT = 1; CLAMP.WMS = CLAMP.WMT = 1;
// TODO // TODO
static BYTE* buff = (BYTE*)_aligned_malloc(1024 * 1024 * 4, 16); static uint8* buff = (uint8*)_aligned_malloc(1024 * 1024 * 4, 16);
static int pitch = 1024 * 4; static int pitch = 1024 * 4;
m_mem.ReadTexture(r, buff, pitch, TEX0, m_env.TEXA, CLAMP); m_mem.ReadTexture(r, buff, pitch, TEX0, m_env.TEXA, CLAMP);
@ -134,9 +134,9 @@ protected:
if(PRIM->TME && context->TEX0.TCC) if(PRIM->TME && context->TEX0.TCC)
{ {
DWORD bpp = GSLocalMemory::m_psm[context->TEX0.PSM].trbpp; uint32 bpp = GSLocalMemory::m_psm[context->TEX0.PSM].trbpp;
DWORD cbpp = GSLocalMemory::m_psm[context->TEX0.CPSM].trbpp; uint32 cbpp = GSLocalMemory::m_psm[context->TEX0.CPSM].trbpp;
DWORD pal = GSLocalMemory::m_psm[context->TEX0.PSM].pal; uint32 pal = GSLocalMemory::m_psm[context->TEX0.PSM].pal;
if(bpp == 32) if(bpp == 32)
{ {
@ -177,6 +177,8 @@ protected:
if(a.z > 0xff) a.z = 0xff; if(a.z > 0xff) a.z = 0xff;
break; break;
case TFX_HIGHLIGHT2: case TFX_HIGHLIGHT2:
a.x = a.y;
a.z = a.w;
break; break;
default: default:
__assume(0); __assume(0);
@ -188,7 +190,7 @@ protected:
m_vtrace.m_alpha.valid = true; m_vtrace.m_alpha.valid = true;
} }
bool TryAlphaTest(DWORD& fm, DWORD& zm) bool TryAlphaTest(uint32& fm, uint32& zm)
{ {
const GSDrawingContext* context = m_context; const GSDrawingContext* context = m_context;
@ -440,11 +442,11 @@ protected:
} }
*/ */
CRect r;
int w = 1 << context->TEX0.TW; int w = 1 << context->TEX0.TW;
int h = 1 << context->TEX0.TH; int h = 1 << context->TEX0.TH;
GSVector4i r;
MinMaxUV(w, h, r, p.sel.fst); MinMaxUV(w, h, r, p.sel.fst);
const GSTextureCacheSW::GSTexture* t = m_tc->Lookup(context->TEX0, env.TEXA, &r); const GSTextureCacheSW::GSTexture* t = m_tc->Lookup(context->TEX0, env.TEXA, &r);
@ -491,7 +493,7 @@ protected:
if(PRIM->ABE && !context->ALPHA.IsOpaque(amin, amax) || PRIM->AA1) if(PRIM->ABE && !context->ALPHA.IsOpaque(amin, amax) || PRIM->AA1)
{ {
p.sel.abe = PRIM->ABE; p.sel.abe = PRIM->ABE;
p.sel.ababcd = context->ALPHA.ai32[0]; p.sel.ababcd = context->ALPHA.u32[0];
if(env.PABE.PABE) if(env.PABE.PABE)
{ {
@ -572,14 +574,14 @@ protected:
{ {
s = format("c:\\temp1\\_%05d_f%I64d_rt0_%05x_%d.bmp", s_n, frame, m_context->FRAME.Block(), m_context->FRAME.PSM); s = format("c:\\temp1\\_%05d_f%I64d_rt0_%05x_%d.bmp", s_n, frame, m_context->FRAME.Block(), m_context->FRAME.PSM);
m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, GetFrameSize().cx, 512);//GetFrameSize(1).cy); m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, GetFrameRect().width(), 512);//GetFrameSize(1).cy);
} }
if(s_savez) if(s_savez)
{ {
s = format("c:\\temp1\\_%05d_f%I64d_rz0_%05x_%d.bmp", s_n, frame, m_context->ZBUF.Block(), m_context->ZBUF.PSM); s = format("c:\\temp1\\_%05d_f%I64d_rz0_%05x_%d.bmp", s_n, frame, m_context->ZBUF.Block(), m_context->ZBUF.PSM);
m_mem.SaveBMP(s, m_context->ZBUF.Block(), m_context->FRAME.FBW, m_context->ZBUF.PSM, GetFrameSize().cx, 512); m_mem.SaveBMP(s, m_context->ZBUF.Block(), m_context->FRAME.FBW, m_context->ZBUF.PSM, GetFrameRect().width(), 512);
} }
s_n++; s_n++;
@ -604,16 +606,7 @@ protected:
m_perfmon.Put(GSPerfMon::Prim, stats.prims); m_perfmon.Put(GSPerfMon::Prim, stats.prims);
m_perfmon.Put(GSPerfMon::Fillrate, stats.pixels); m_perfmon.Put(GSPerfMon::Fillrate, stats.pixels);
GSVector4i pos(m_vtrace.m_min.p.xyxy(m_vtrace.m_max.p)); GSVector4i r = GSVector4i(m_vtrace.m_min.p.xyxy(m_vtrace.m_max.p)).rintersect(data.scissor);
GSVector4i scissor = data.scissor;
CRect r;
r.left = max(scissor.x, min(scissor.z, pos.x));
r.top = max(scissor.y, min(scissor.w, pos.y));
r.right = max(scissor.x, min(scissor.z, pos.z));
r.bottom = max(scissor.y, min(scissor.w, pos.w));
GIFRegBITBLTBUF BITBLTBUF; GIFRegBITBLTBUF BITBLTBUF;
@ -645,14 +638,14 @@ protected:
{ {
s = format("c:\\temp1\\_%05d_f%I64d_rt1_%05x_%d.bmp", s_n, frame, m_context->FRAME.Block(), m_context->FRAME.PSM); s = format("c:\\temp1\\_%05d_f%I64d_rt1_%05x_%d.bmp", s_n, frame, m_context->FRAME.Block(), m_context->FRAME.PSM);
m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, GetFrameSize().cx, 512);//GetFrameSize(1).cy); m_mem.SaveBMP(s, m_context->FRAME.Block(), m_context->FRAME.FBW, m_context->FRAME.PSM, GetFrameRect().width(), 512);//GetFrameSize(1).cy);
} }
if(s_savez) if(s_savez)
{ {
s = format("c:\\temp1\\_%05d_f%I64d_rz1_%05x_%d.bmp", s_n, frame, m_context->ZBUF.Block(), m_context->ZBUF.PSM); s = format("c:\\temp1\\_%05d_f%I64d_rz1_%05x_%d.bmp", s_n, frame, m_context->ZBUF.Block(), m_context->ZBUF.PSM);
m_mem.SaveBMP(s, m_context->ZBUF.Block(), m_context->FRAME.FBW, m_context->ZBUF.PSM, GetFrameSize().cx, 512); m_mem.SaveBMP(s, m_context->ZBUF.Block(), m_context->FRAME.FBW, m_context->ZBUF.PSM, GetFrameRect().width(), 512);
} }
s_n++; s_n++;
@ -668,12 +661,12 @@ protected:
} }
} }
void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, CRect r) void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& r)
{ {
m_tc->InvalidateVideoMem(BITBLTBUF, r); m_tc->InvalidateVideoMem(BITBLTBUF, r);
} }
void MinMaxUV(int w, int h, CRect& r, DWORD fst) void MinMaxUV(int w, int h, GSVector4i& r, uint32 fst)
{ {
const GSDrawingContext* context = m_context; const GSDrawingContext* context = m_context;
@ -778,13 +771,11 @@ protected:
} }
} }
r = vr; r = vr.rintersect(GSVector4i(0, 0, w, h));
r &= CRect(0, 0, w, h);
} }
public: public:
GSRendererSW(BYTE* base, bool mt, void (*irq)(), const GSRendererSettings& rs, int threads) GSRendererSW(uint8* base, bool mt, void (*irq)(), const GSRendererSettings& rs, int threads)
: GSRendererT(base, mt, irq, rs) : GSRendererT(base, mt, irq, rs)
{ {
m_rl.Create<GSDrawScanline>(this, threads); m_rl.Create<GSDrawScanline>(this, threads);
@ -799,12 +790,12 @@ public:
delete m_tc; delete m_tc;
} }
template<DWORD prim, DWORD tme, DWORD fst> template<uint32 prim, uint32 tme, uint32 fst>
void VertexKick(bool skip) void VertexKick(bool skip)
{ {
const GSDrawingContext* context = m_context; const GSDrawingContext* context = m_context;
GSVector4i xy = GSVector4i::load((int)m_v.XYZ.ai32[0]); GSVector4i xy = GSVector4i::load((int)m_v.XYZ.u32[0]);
xy = xy.insert16<3>(m_v.FOG.F); xy = xy.insert16<3>(m_v.FOG.F);
xy = xy.upl16(); xy = xy.upl16();
@ -814,7 +805,7 @@ public:
v.p = GSVector4(xy) * g_pos_scale; v.p = GSVector4(xy) * g_pos_scale;
v.c = GSVector4(GSVector4i::load((int)m_v.RGBAQ.ai32[0]).u8to32() << 7); v.c = GSVector4(GSVector4i::load((int)m_v.RGBAQ.u32[0]).u8to32() << 7);
if(tme) if(tme)
{ {
@ -839,9 +830,9 @@ public:
dst = v; dst = v;
dst.p.z = (float)min(m_v.XYZ.Z, 0xffffff00); // max value which can survive the DWORD => float => DWORD conversion dst.p.z = (float)min(m_v.XYZ.Z, 0xffffff00); // max value which can survive the uint32 => float => uint32 conversion
DWORD count = 0; int count = 0;
if(GSVertexSW* v = DrawingKick<prim>(skip, count)) if(GSVertexSW* v = DrawingKick<prim>(skip, count))
{ {
@ -951,7 +942,7 @@ if(!m_dump)
m_count = 2; m_count = 2;
UINT32 tmp = PRIM->PRIM; uint32 tmp = PRIM->PRIM;
PRIM->PRIM = GS_SPRITE; PRIM->PRIM = GS_SPRITE;
Flush(); Flush();

100
plugins/GSdx/GSScanlineEnvironment.h
View File

@ -28,63 +28,63 @@ union GSScanlineSelector
{ {
struct struct
{ {
DWORD fpsm:2; // 0 uint32 fpsm:2; // 0
DWORD zpsm:2; // 2 uint32 zpsm:2; // 2
DWORD ztst:2; // 4 (0: off, 1: write, 2: test (ge), 3: test (g)) uint32 ztst:2; // 4 (0: off, 1: write, 2: test (ge), 3: test (g))
DWORD atst:3; // 6 uint32 atst:3; // 6
DWORD afail:2; // 9 uint32 afail:2; // 9
DWORD iip:1; // 11 uint32 iip:1; // 11
DWORD tfx:3; // 12 uint32 tfx:3; // 12
DWORD tcc:1; // 15 uint32 tcc:1; // 15
DWORD fst:1; // 16 uint32 fst:1; // 16
DWORD ltf:1; // 17 uint32 ltf:1; // 17
DWORD tlu:1; // 18 uint32 tlu:1; // 18
DWORD fge:1; // 19 uint32 fge:1; // 19
DWORD date:1; // 20 uint32 date:1; // 20
DWORD abe:1; // 21 uint32 abe:1; // 21
DWORD aba:2; // 22 uint32 aba:2; // 22
DWORD abb:2; // 24 uint32 abb:2; // 24
DWORD abc:2; // 26 uint32 abc:2; // 26
DWORD abd:2; // 28 uint32 abd:2; // 28
DWORD pabe:1; // 30 uint32 pabe:1; // 30
DWORD aa1:1; // 31 uint32 aa1:1; // 31
DWORD fwrite:1; // 32 uint32 fwrite:1; // 32
DWORD ftest:1; // 33 uint32 ftest:1; // 33
DWORD rfb:1; // 34 uint32 rfb:1; // 34
DWORD zwrite:1; // 35 uint32 zwrite:1; // 35
DWORD ztest:1; // 36 uint32 ztest:1; // 36
DWORD zoverflow:1; // 37 (z max >= 0x80000000) uint32 zoverflow:1; // 37 (z max >= 0x80000000)
DWORD wms:2; // 38 uint32 wms:2; // 38
DWORD wmt:2; // 40 uint32 wmt:2; // 40
DWORD datm:1; // 42 uint32 datm:1; // 42
DWORD colclamp:1; // 43 uint32 colclamp:1; // 43
DWORD fba:1; // 44 uint32 fba:1; // 44
DWORD dthe:1; // 45 uint32 dthe:1; // 45
DWORD sprite:1; // 46 uint32 sprite:1; // 46
DWORD edge:1; // 47 uint32 edge:1; // 47
}; };
struct struct
{ {
DWORD _pad1:22; uint32 _pad1:22;
DWORD ababcd:8; uint32 ababcd:8;
DWORD _pad2:2; uint32 _pad2:2;
DWORD fb:2; uint32 fb:2;
DWORD _pad3:1; uint32 _pad3:1;
DWORD zb:2; uint32 zb:2;
}; };
struct struct
{ {
DWORD lo; uint32 lo;
DWORD hi; uint32 hi;
}; };
UINT64 key; uint64 key;
operator DWORD() {return lo;} operator uint32() {return lo;}
operator UINT64() {return key;} operator uint64() {return key;}
bool IsSolidRect() bool IsSolidRect()
{ {
@ -105,22 +105,22 @@ __declspec(align(16)) struct GSScanlineParam
void* vm; void* vm;
const void* tex; const void* tex;
const DWORD* clut; const uint32* clut;
DWORD tw; uint32 tw;
GSLocalMemory::Offset* fbo; GSLocalMemory::Offset* fbo;
GSLocalMemory::Offset* zbo; GSLocalMemory::Offset* zbo;
GSLocalMemory::Offset4* fzbo; GSLocalMemory::Offset4* fzbo;
DWORD fm, zm; uint32 fm, zm;
}; };
__declspec(align(16)) struct GSScanlineEnvironment __declspec(align(16)) struct GSScanlineEnvironment
{ {
void* vm; void* vm;
const void* tex; const void* tex;
const DWORD* clut; const uint32* clut;
DWORD tw; uint32 tw;
GSVector4i* fbr; GSVector4i* fbr;
GSVector4i* zbr; GSVector4i* zbr;

18
plugins/GSdx/GSSettingsDlg.cpp
View File

@ -165,13 +165,13 @@ BOOL GSSettingsDlg::OnInitDialog()
if(CComPtr<IDirect3D9> d3d = Direct3DCreate9(D3D_SDK_VERSION)) if(CComPtr<IDirect3D9> d3d = Direct3DCreate9(D3D_SDK_VERSION))
{ {
UINT ModeWidth = pApp->GetProfileInt(_T("Settings"), _T("ModeWidth"), 0); uint32 ModeWidth = pApp->GetProfileInt(_T("Settings"), _T("ModeWidth"), 0);
UINT ModeHeight = pApp->GetProfileInt(_T("Settings"), _T("ModeHeight"), 0); uint32 ModeHeight = pApp->GetProfileInt(_T("Settings"), _T("ModeHeight"), 0);
UINT ModeRefreshRate = pApp->GetProfileInt(_T("Settings"), _T("ModeRefreshRate"), 0); uint32 ModeRefreshRate = pApp->GetProfileInt(_T("Settings"), _T("ModeRefreshRate"), 0);
UINT nModes = d3d->GetAdapterModeCount(D3DADAPTER_DEFAULT, D3DFMT_X8R8G8B8); uint32 nModes = d3d->GetAdapterModeCount(D3DADAPTER_DEFAULT, D3DFMT_X8R8G8B8);
for(UINT i = 0; i < nModes; i++) for(uint32 i = 0; i < nModes; i++)
{ {
D3DDISPLAYMODE mode; D3DDISPLAYMODE mode;
@ -259,22 +259,22 @@ void GSSettingsDlg::OnOK()
if(m_renderer.GetCurSel() >= 0) if(m_renderer.GetCurSel() >= 0)
{ {
pApp->WriteProfileInt(_T("Settings"), _T("Renderer"), (DWORD)m_renderer.GetItemData(m_renderer.GetCurSel())); pApp->WriteProfileInt(_T("Settings"), _T("Renderer"), (uint32)m_renderer.GetItemData(m_renderer.GetCurSel()));
} }
if(m_psversion.GetCurSel() >= 0) if(m_psversion.GetCurSel() >= 0)
{ {
pApp->WriteProfileInt(_T("Settings"), _T("PixelShaderVersion2"), (DWORD)m_psversion.GetItemData(m_psversion.GetCurSel())); pApp->WriteProfileInt(_T("Settings"), _T("PixelShaderVersion2"), (uint32)m_psversion.GetItemData(m_psversion.GetCurSel()));
} }
if(m_interlace.GetCurSel() >= 0) if(m_interlace.GetCurSel() >= 0)
{ {
pApp->WriteProfileInt(_T("Settings"), _T("Interlace"), (DWORD)m_interlace.GetItemData(m_interlace.GetCurSel())); pApp->WriteProfileInt(_T("Settings"), _T("Interlace"), (uint32)m_interlace.GetItemData(m_interlace.GetCurSel()));
} }
if(m_aspectratio.GetCurSel() >= 0) if(m_aspectratio.GetCurSel() >= 0)
{ {
pApp->WriteProfileInt(_T("Settings"), _T("AspectRatio"), (DWORD)m_aspectratio.GetItemData(m_aspectratio.GetCurSel())); pApp->WriteProfileInt(_T("Settings"), _T("AspectRatio"), (uint32)m_aspectratio.GetItemData(m_aspectratio.GetCurSel()));
} }
pApp->WriteProfileInt(_T("Settings"), _T("filter"), m_filter); pApp->WriteProfileInt(_T("Settings"), _T("filter"), m_filter);

2
plugins/GSdx/GSSetupPrimCodeGenerator.cpp
View File

@ -24,7 +24,7 @@
#include "StdAfx.h" #include "StdAfx.h"
#include "GSSetupPrimCodeGenerator.h" #include "GSSetupPrimCodeGenerator.h"
GSSetupPrimCodeGenerator::GSSetupPrimCodeGenerator(GSScanlineEnvironment& env, UINT64 key, void* ptr, size_t maxsize) GSSetupPrimCodeGenerator::GSSetupPrimCodeGenerator(GSScanlineEnvironment& env, uint64 key, void* ptr, size_t maxsize)
: CodeGenerator(maxsize, ptr) : CodeGenerator(maxsize, ptr)
, m_env(env) , m_env(env)
{ {

4
plugins/GSdx/GSSetupPrimCodeGenerator.h
View File

@ -38,7 +38,7 @@ class GSSetupPrimCodeGenerator : public CodeGenerator
GSScanlineEnvironment& m_env; GSScanlineEnvironment& m_env;
GSScanlineSelector m_sel; GSScanlineSelector m_sel;
struct {DWORD z:1, f:1, t:1, c:1;} m_en; struct {uint32 z:1, f:1, t:1, c:1;} m_en;
void Generate(); void Generate();
@ -47,5 +47,5 @@ class GSSetupPrimCodeGenerator : public CodeGenerator
void Color(); void Color();
public: public:
GSSetupPrimCodeGenerator(GSScanlineEnvironment& env, UINT64 key, void* ptr, size_t maxsize); GSSetupPrimCodeGenerator(GSScanlineEnvironment& env, uint64 key, void* ptr, size_t maxsize);
}; };

271
plugins/GSdx/GSState.cpp
View File

@ -22,7 +22,7 @@
#include "stdafx.h" #include "stdafx.h"
#include "GSState.h" #include "GSState.h"
GSState::GSState(BYTE* base, bool mt, void (*irq)()) GSState::GSState(uint8* base, bool mt, void (*irq)())
: m_mt(mt) : m_mt(mt)
, m_irq(irq) , m_irq(irq)
, m_crc(0) , m_crc(0)
@ -202,112 +202,65 @@ void GSState::ResetHandlers()
m_fpGIFRegHandlers[GIF_A_D_REG_LABEL] = &GSState::GIFRegHandlerLABEL; m_fpGIFRegHandlers[GIF_A_D_REG_LABEL] = &GSState::GIFRegHandlerLABEL;
} }
CPoint GSState::GetDisplayPos(int i) GSVector4i GSState::GetDisplayRect(int i)
{ {
ASSERT(i >= 0 && i < 2); if(i < 0) i = IsEnabled(1) ? 1 : 0;
CPoint p; GSVector4i r;
p.x = m_regs->DISP[i].DISPLAY.DX / (m_regs->DISP[i].DISPLAY.MAGH + 1); r.left = m_regs->DISP[i].DISPLAY.DX / (m_regs->DISP[i].DISPLAY.MAGH + 1);
p.y = m_regs->DISP[i].DISPLAY.DY / (m_regs->DISP[i].DISPLAY.MAGV + 1); r.top = m_regs->DISP[i].DISPLAY.DY / (m_regs->DISP[i].DISPLAY.MAGV + 1);
r.right = r.left + (m_regs->DISP[i].DISPLAY.DW + 1) / (m_regs->DISP[i].DISPLAY.MAGH + 1);
r.bottom = r.top + (m_regs->DISP[i].DISPLAY.DH + 1) / (m_regs->DISP[i].DISPLAY.MAGV + 1);
return p; return r;
} }
CSize GSState::GetDisplaySize(int i) GSVector4i GSState::GetFrameRect(int i)
{ {
ASSERT(i >= 0 && i < 2); if(i < 0) i = IsEnabled(1) ? 1 : 0;
CSize s; GSVector4i r = GetDisplayRect(i);
s.cx = (m_regs->DISP[i].DISPLAY.DW + 1) / (m_regs->DISP[i].DISPLAY.MAGH + 1); int w = r.width();
s.cy = (m_regs->DISP[i].DISPLAY.DH + 1) / (m_regs->DISP[i].DISPLAY.MAGV + 1); int h = r.height();
return s; if(m_regs->SMODE2.INT && m_regs->SMODE2.FFMD && h > 1) h >>= 1;
r.left = m_regs->DISP[i].DISPFB.DBX;
r.top = m_regs->DISP[i].DISPFB.DBY;
r.right = r.left + w;
r.bottom = r.top + h;
return r;
} }
CRect GSState::GetDisplayRect(int i) GSVector4i GSState::GetDeviceRect(int i)
{
return CRect(GetDisplayPos(i), GetDisplaySize(i));
}
CSize GSState::GetDisplayPos()
{
return GetDisplayPos(IsEnabled(1) ? 1 : 0);
}
CSize GSState::GetDisplaySize()
{
return GetDisplaySize(IsEnabled(1) ? 1 : 0);
}
CRect GSState::GetDisplayRect()
{
return GetDisplayRect(IsEnabled(1) ? 1 : 0);
}
CPoint GSState::GetFramePos(int i)
{
ASSERT(i >= 0 && i < 2);
return CPoint(m_regs->DISP[i].DISPFB.DBX, m_regs->DISP[i].DISPFB.DBY);
}
CSize GSState::GetFrameSize(int i)
{
CSize s = GetDisplaySize(i);
if(m_regs->SMODE2.INT && m_regs->SMODE2.FFMD && s.cy > 1) s.cy >>= 1;
return s;
}
CRect GSState::GetFrameRect(int i)
{
return CRect(GetFramePos(i), GetFrameSize(i));
}
CSize GSState::GetFramePos()
{
return GetFramePos(IsEnabled(1) ? 1 : 0);
}
CSize GSState::GetFrameSize()
{
return GetFrameSize(IsEnabled(1) ? 1 : 0);
}
CRect GSState::GetFrameRect()
{
return GetFrameRect(IsEnabled(1) ? 1 : 0);
}
CSize GSState::GetDeviceSize(int i)
{ {
// TODO: other params of SMODE1 should affect the true device display size // TODO: other params of SMODE1 should affect the true device display size
// TODO2: pal games at 60Hz // TODO2: pal games at 60Hz
CSize s = GetDisplaySize(i); if(i < 0) i = IsEnabled(1) ? 1 : 0;
if(s.cy == 2 * 416 || s.cy == 2 * 448 || s.cy == 2 * 512) GSVector4i r = GetDisplayRect(i);
int w = r.width();
int h = r.height();
if(h == 2 * 416 || h == 2 * 448 || h == 2 * 512)
{ {
s.cy /= 2; h /= 2;
} }
else else
{ {
s.cy = (m_regs->SMODE1.CMOD & 1) ? 512 : 448; h = (m_regs->SMODE1.CMOD & 1) ? 512 : 448;
} }
return s; return GSVector4i(0, 0, w, h);
} }
CSize GSState::GetDeviceSize()
{
return GetDeviceSize(IsEnabled(1) ? 1 : 0);
}
bool GSState::IsEnabled(int i) bool GSState::IsEnabled(int i)
{ {
ASSERT(i >= 0 && i < 2); ASSERT(i >= 0 && i < 2);
@ -349,12 +302,12 @@ void GSState::GIFPackedRegHandlerRGBA(GIFPackedReg* r)
GSVector4i mask = GSVector4i::load(0x0c080400); GSVector4i mask = GSVector4i::load(0x0c080400);
GSVector4i v = GSVector4i::load<false>(r).shuffle8(mask); GSVector4i v = GSVector4i::load<false>(r).shuffle8(mask);
m_v.RGBAQ.ai32[0] = (UINT32)GSVector4i::store(v); m_v.RGBAQ.u32[0] = (uint32)GSVector4i::store(v);
#elif _M_SSE >= 0x200 #elif _M_SSE >= 0x200
GSVector4i v = GSVector4i::load<false>(r) & GSVector4i::x000000ff(); GSVector4i v = GSVector4i::load<false>(r) & GSVector4i::x000000ff();
m_v.RGBAQ.ai32[0] = v.rgba32(); m_v.RGBAQ.u32[0] = v.rgba32();
#else #else
@ -372,12 +325,12 @@ void GSState::GIFPackedRegHandlerSTQ(GIFPackedReg* r)
{ {
#if defined(_M_AMD64) #if defined(_M_AMD64)
m_v.ST.i64 = r->ai64[0]; m_v.ST.u64 = r->u64[0];
#elif _M_SSE >= 0x200 #elif _M_SSE >= 0x200
GSVector4i v = GSVector4i::loadl(r); GSVector4i v = GSVector4i::loadl(r);
GSVector4i::storel(&m_v.ST.i64, v); GSVector4i::storel(&m_v.ST.u64, v);
#else #else
@ -394,7 +347,7 @@ void GSState::GIFPackedRegHandlerUV(GIFPackedReg* r)
#if _M_SSE >= 0x200 #if _M_SSE >= 0x200
GSVector4i v = GSVector4i::loadl(r) & GSVector4i::x00003fff(); GSVector4i v = GSVector4i::loadl(r) & GSVector4i::x00003fff();
m_v.UV.ai32[0] = (UINT32)GSVector4i::store(v.ps32(v)); m_v.UV.u32[0] = (uint32)GSVector4i::store(v.ps32(v));
#else #else
@ -425,12 +378,12 @@ void GSState::GIFPackedRegHandlerXYZ2(GIFPackedReg* r)
template<int i> void GSState::GIFPackedRegHandlerTEX0(GIFPackedReg* r) template<int i> void GSState::GIFPackedRegHandlerTEX0(GIFPackedReg* r)
{ {
GIFRegHandlerTEX0<i>((GIFReg*)&r->ai64[0]); GIFRegHandlerTEX0<i>((GIFReg*)&r->u64[0]);
} }
template<int i> void GSState::GIFPackedRegHandlerCLAMP(GIFPackedReg* r) template<int i> void GSState::GIFPackedRegHandlerCLAMP(GIFPackedReg* r)
{ {
GIFRegHandlerCLAMP<i>((GIFReg*)&r->ai64[0]); GIFRegHandlerCLAMP<i>((GIFReg*)&r->u64[0]);
} }
void GSState::GIFPackedRegHandlerFOG(GIFPackedReg* r) void GSState::GIFPackedRegHandlerFOG(GIFPackedReg* r)
@ -440,17 +393,17 @@ void GSState::GIFPackedRegHandlerFOG(GIFPackedReg* r)
void GSState::GIFPackedRegHandlerXYZF3(GIFPackedReg* r) void GSState::GIFPackedRegHandlerXYZF3(GIFPackedReg* r)
{ {
GIFRegHandlerXYZF3((GIFReg*)&r->ai64[0]); GIFRegHandlerXYZF3((GIFReg*)&r->u64[0]);
} }
void GSState::GIFPackedRegHandlerXYZ3(GIFPackedReg* r) void GSState::GIFPackedRegHandlerXYZ3(GIFPackedReg* r)
{ {
GIFRegHandlerXYZ3((GIFReg*)&r->ai64[0]); GIFRegHandlerXYZ3((GIFReg*)&r->u64[0]);
} }
void GSState::GIFPackedRegHandlerA_D(GIFPackedReg* r) void GSState::GIFPackedRegHandlerA_D(GIFPackedReg* r)
{ {
(this->*m_fpGIFRegHandlers[(BYTE)r->A_D.ADDR])(&r->r); (this->*m_fpGIFRegHandlers[r->A_D.ADDR])(&r->r);
} }
void GSState::GIFPackedRegHandlerNOP(GIFPackedReg* r) void GSState::GIFPackedRegHandlerNOP(GIFPackedReg* r)
@ -470,7 +423,7 @@ void GSState::GIFRegHandlerPRIM(GIFReg* r)
if(GSUtil::GetPrimClass(m_env.PRIM.PRIM) == GSUtil::GetPrimClass(r->PRIM.PRIM)) if(GSUtil::GetPrimClass(m_env.PRIM.PRIM) == GSUtil::GetPrimClass(r->PRIM.PRIM))
{ {
if(((m_env.PRIM.i64 ^ r->PRIM.i64) & ~7) != 0) if(((m_env.PRIM.u64 ^ r->PRIM.u64) & ~7) != 0)
{ {
Flush(); Flush();
} }
@ -502,7 +455,7 @@ void GSState::GIFRegHandlerST(GIFReg* r)
void GSState::GIFRegHandlerUV(GIFReg* r) void GSState::GIFRegHandlerUV(GIFReg* r)
{ {
m_v.UV.ai32[0] = r->UV.ai32[0] & 0x3fff3fff; m_v.UV.u32[0] = r->UV.u32[0] & 0x3fff3fff;
} }
void GSState::GIFRegHandlerXYZF2(GIFReg* r) void GSState::GIFRegHandlerXYZF2(GIFReg* r)
@ -513,9 +466,9 @@ void GSState::GIFRegHandlerXYZF2(GIFReg* r)
m_v.XYZ.Z = r->XYZF.Z; m_v.XYZ.Z = r->XYZF.Z;
m_v.FOG.F = r->XYZF.F; m_v.FOG.F = r->XYZF.F;
*/ */
m_v.XYZ.ai32[0] = r->XYZF.ai32[0]; m_v.XYZ.u32[0] = r->XYZF.u32[0];
m_v.XYZ.ai32[1] = r->XYZF.ai32[1] & 0x00ffffff; m_v.XYZ.u32[1] = r->XYZF.u32[1] & 0x00ffffff;
m_v.FOG.ai32[1] = r->XYZF.ai32[1] & 0xff000000; m_v.FOG.u32[1] = r->XYZF.u32[1] & 0xff000000;
VertexKick(false); VertexKick(false);
} }
@ -533,7 +486,7 @@ template<int i> void GSState::GIFRegHandlerTEX0(GIFReg* r)
bool wt = m_mem.m_clut.WriteTest(r->TEX0, m_env.TEXCLUT); bool wt = m_mem.m_clut.WriteTest(r->TEX0, m_env.TEXCLUT);
if(wt || PRIM->CTXT == i && !(m_env.CTXT[i].TEX0 == (GSVector4i)r->TEX0).alltrue()) if(wt || PRIM->CTXT == i && !((GSVector4i)r->TEX0).eq(m_env.CTXT[i].TEX0))
{ {
Flush(); Flush();
} }
@ -558,7 +511,7 @@ template<int i> void GSState::GIFRegHandlerTEX0(GIFReg* r)
template<int i> void GSState::GIFRegHandlerCLAMP(GIFReg* r) template<int i> void GSState::GIFRegHandlerCLAMP(GIFReg* r)
{ {
if(PRIM->CTXT == i && !(m_env.CTXT[i].CLAMP == (GSVector4i)r->CLAMP).alltrue()) if(PRIM->CTXT == i && !((GSVector4i)r->CLAMP).eq(m_env.CTXT[i].CLAMP))
{ {
Flush(); Flush();
} }
@ -579,9 +532,9 @@ void GSState::GIFRegHandlerXYZF3(GIFReg* r)
m_v.XYZ.Z = r->XYZF.Z; m_v.XYZ.Z = r->XYZF.Z;
m_v.FOG.F = r->XYZF.F; m_v.FOG.F = r->XYZF.F;
*/ */
m_v.XYZ.ai32[0] = r->XYZF.ai32[0]; m_v.XYZ.u32[0] = r->XYZF.u32[0];
m_v.XYZ.ai32[1] = r->XYZF.ai32[1] & 0x00ffffff; m_v.XYZ.u32[1] = r->XYZF.u32[1] & 0x00ffffff;
m_v.FOG.ai32[1] = r->XYZF.ai32[1] & 0xff000000; m_v.FOG.u32[1] = r->XYZF.u32[1] & 0xff000000;
VertexKick(true); VertexKick(true);
} }
@ -599,7 +552,7 @@ void GSState::GIFRegHandlerNOP(GIFReg* r)
template<int i> void GSState::GIFRegHandlerTEX1(GIFReg* r) template<int i> void GSState::GIFRegHandlerTEX1(GIFReg* r)
{ {
if(PRIM->CTXT == i && !(m_env.CTXT[i].TEX1 == (GSVector4i)r->TEX1).alltrue()) if(PRIM->CTXT == i && !((GSVector4i)r->TEX1).eq(m_env.CTXT[i].TEX1))
{ {
Flush(); Flush();
} }
@ -613,7 +566,7 @@ template<int i> void GSState::GIFRegHandlerTEX2(GIFReg* r)
UINT64 mask = 0xFFFFFFE003F00000ui64; // TEX2 bits UINT64 mask = 0xFFFFFFE003F00000ui64; // TEX2 bits
r->i64 = (r->i64 & mask) | (m_env.CTXT[i].TEX0.i64 & ~mask); r->u64 = (r->u64 & mask) | (m_env.CTXT[i].TEX0.u64 & ~mask);
GIFRegHandlerTEX0<i>(r); GIFRegHandlerTEX0<i>(r);
} }
@ -622,7 +575,7 @@ template<int i> void GSState::GIFRegHandlerXYOFFSET(GIFReg* r)
{ {
GSVector4i o = (GSVector4i)r->XYOFFSET & GSVector4i::x0000ffff(); GSVector4i o = (GSVector4i)r->XYOFFSET & GSVector4i::x0000ffff();
if(!(m_env.CTXT[i].XYOFFSET == o).alltrue()) if(!o.eq(m_env.CTXT[i].XYOFFSET))
{ {
Flush(); Flush();
} }
@ -634,7 +587,7 @@ template<int i> void GSState::GIFRegHandlerXYOFFSET(GIFReg* r)
void GSState::GIFRegHandlerPRMODECONT(GIFReg* r) void GSState::GIFRegHandlerPRMODECONT(GIFReg* r)
{ {
if(!(m_env.PRMODECONT == (GSVector4i)r->PRMODECONT).alltrue()) if(!((GSVector4i)r->PRMODECONT).eq(m_env.PRMODECONT))
{ {
Flush(); Flush();
} }
@ -657,7 +610,7 @@ void GSState::GIFRegHandlerPRMODE(GIFReg* r)
Flush(); Flush();
} }
UINT32 _PRIM = m_env.PRMODE._PRIM; uint32 _PRIM = m_env.PRMODE._PRIM;
m_env.PRMODE = (GSVector4i)r->PRMODE; m_env.PRMODE = (GSVector4i)r->PRMODE;
m_env.PRMODE._PRIM = _PRIM; m_env.PRMODE._PRIM = _PRIM;
@ -668,7 +621,7 @@ void GSState::GIFRegHandlerPRMODE(GIFReg* r)
void GSState::GIFRegHandlerTEXCLUT(GIFReg* r) void GSState::GIFRegHandlerTEXCLUT(GIFReg* r)
{ {
if(!(m_env.TEXCLUT == (GSVector4i)r->TEXCLUT).alltrue()) if(!((GSVector4i)r->TEXCLUT).eq(m_env.TEXCLUT))
{ {
Flush(); Flush();
} }
@ -678,7 +631,7 @@ void GSState::GIFRegHandlerTEXCLUT(GIFReg* r)
void GSState::GIFRegHandlerSCANMSK(GIFReg* r) void GSState::GIFRegHandlerSCANMSK(GIFReg* r)
{ {
if(!(m_env.SCANMSK == (GSVector4i)r->SCANMSK).alltrue()) if(!((GSVector4i)r->SCANMSK).eq(m_env.SCANMSK))
{ {
Flush(); Flush();
} }
@ -688,7 +641,7 @@ void GSState::GIFRegHandlerSCANMSK(GIFReg* r)
template<int i> void GSState::GIFRegHandlerMIPTBP1(GIFReg* r) template<int i> void GSState::GIFRegHandlerMIPTBP1(GIFReg* r)
{ {
if(PRIM->CTXT == i && !(m_env.CTXT[i].MIPTBP1 == (GSVector4i)r->MIPTBP1).alltrue()) if(PRIM->CTXT == i && !((GSVector4i)r->MIPTBP1).eq(m_env.CTXT[i].MIPTBP1))
{ {
Flush(); Flush();
} }
@ -698,7 +651,7 @@ template<int i> void GSState::GIFRegHandlerMIPTBP1(GIFReg* r)
template<int i> void GSState::GIFRegHandlerMIPTBP2(GIFReg* r) template<int i> void GSState::GIFRegHandlerMIPTBP2(GIFReg* r)
{ {
if(PRIM->CTXT == i && !(m_env.CTXT[i].MIPTBP2 == (GSVector4i)r->MIPTBP2).alltrue()) if(PRIM->CTXT == i && !((GSVector4i)r->MIPTBP2).eq(m_env.CTXT[i].MIPTBP2))
{ {
Flush(); Flush();
} }
@ -708,7 +661,7 @@ template<int i> void GSState::GIFRegHandlerMIPTBP2(GIFReg* r)
void GSState::GIFRegHandlerTEXA(GIFReg* r) void GSState::GIFRegHandlerTEXA(GIFReg* r)
{ {
if(!(m_env.TEXA == (GSVector4i)r->TEXA).alltrue()) if(!((GSVector4i)r->TEXA).eq(m_env.TEXA))
{ {
Flush(); Flush();
} }
@ -718,7 +671,7 @@ void GSState::GIFRegHandlerTEXA(GIFReg* r)
void GSState::GIFRegHandlerFOGCOL(GIFReg* r) void GSState::GIFRegHandlerFOGCOL(GIFReg* r)
{ {
if(!(m_env.FOGCOL == (GSVector4i)r->FOGCOL).alltrue()) if(!((GSVector4i)r->FOGCOL).eq(m_env.FOGCOL))
{ {
Flush(); Flush();
} }
@ -735,7 +688,7 @@ void GSState::GIFRegHandlerTEXFLUSH(GIFReg* r)
template<int i> void GSState::GIFRegHandlerSCISSOR(GIFReg* r) template<int i> void GSState::GIFRegHandlerSCISSOR(GIFReg* r)
{ {
if(PRIM->CTXT == i && !(m_env.CTXT[i].SCISSOR == (GSVector4i)r->SCISSOR).alltrue()) if(PRIM->CTXT == i && !((GSVector4i)r->SCISSOR).eq(m_env.CTXT[i].SCISSOR))
{ {
Flush(); Flush();
} }
@ -752,7 +705,7 @@ template<int i> void GSState::GIFRegHandlerALPHA(GIFReg* r)
ASSERT(r->ALPHA.C != 3); ASSERT(r->ALPHA.C != 3);
ASSERT(r->ALPHA.D != 3); ASSERT(r->ALPHA.D != 3);
if(PRIM->CTXT == i && !(m_env.CTXT[i].ALPHA == (GSVector4i)r->ALPHA).alltrue()) if(PRIM->CTXT == i && !((GSVector4i)r->ALPHA).eq(m_env.CTXT[i].ALPHA))
{ {
Flush(); Flush();
} }
@ -761,14 +714,14 @@ template<int i> void GSState::GIFRegHandlerALPHA(GIFReg* r)
// A/B/C/D == 3? => 2 // A/B/C/D == 3? => 2
m_env.CTXT[i].ALPHA.ai32[0] = ((~m_env.CTXT[i].ALPHA.ai32[0] >> 1) | 0xAA) & m_env.CTXT[i].ALPHA.ai32[0]; m_env.CTXT[i].ALPHA.u32[0] = ((~m_env.CTXT[i].ALPHA.u32[0] >> 1) | 0xAA) & m_env.CTXT[i].ALPHA.u32[0];
} }
void GSState::GIFRegHandlerDIMX(GIFReg* r) void GSState::GIFRegHandlerDIMX(GIFReg* r)
{ {
bool update = false; bool update = false;
if(!(m_env.DIMX == (GSVector4i)r->DIMX).alltrue()) if(!((GSVector4i)r->DIMX).eq(m_env.DIMX))
{ {
Flush(); Flush();
@ -785,7 +738,7 @@ void GSState::GIFRegHandlerDIMX(GIFReg* r)
void GSState::GIFRegHandlerDTHE(GIFReg* r) void GSState::GIFRegHandlerDTHE(GIFReg* r)
{ {
if(!(m_env.DTHE == (GSVector4i)r->DTHE).alltrue()) if(!((GSVector4i)r->DTHE).eq(m_env.DTHE))
{ {
Flush(); Flush();
} }
@ -795,7 +748,7 @@ void GSState::GIFRegHandlerDTHE(GIFReg* r)
void GSState::GIFRegHandlerCOLCLAMP(GIFReg* r) void GSState::GIFRegHandlerCOLCLAMP(GIFReg* r)
{ {
if(!(m_env.COLCLAMP == (GSVector4i)r->COLCLAMP).alltrue()) if(!((GSVector4i)r->COLCLAMP).eq(m_env.COLCLAMP))
{ {
Flush(); Flush();
} }
@ -805,7 +758,7 @@ void GSState::GIFRegHandlerCOLCLAMP(GIFReg* r)
template<int i> void GSState::GIFRegHandlerTEST(GIFReg* r) template<int i> void GSState::GIFRegHandlerTEST(GIFReg* r)
{ {
if(PRIM->CTXT == i && !(m_env.CTXT[i].TEST == (GSVector4i)r->TEST).alltrue()) if(PRIM->CTXT == i && !((GSVector4i)r->TEST).eq(m_env.CTXT[i].TEST))
{ {
Flush(); Flush();
} }
@ -815,7 +768,7 @@ template<int i> void GSState::GIFRegHandlerTEST(GIFReg* r)
void GSState::GIFRegHandlerPABE(GIFReg* r) void GSState::GIFRegHandlerPABE(GIFReg* r)
{ {
if(!(m_env.PABE == (GSVector4i)r->PABE).alltrue()) if(!((GSVector4i)r->PABE).eq(m_env.PABE))
{ {
Flush(); Flush();
} }
@ -825,7 +778,7 @@ void GSState::GIFRegHandlerPABE(GIFReg* r)
template<int i> void GSState::GIFRegHandlerFBA(GIFReg* r) template<int i> void GSState::GIFRegHandlerFBA(GIFReg* r)
{ {
if(PRIM->CTXT == i && !(m_env.CTXT[i].FBA == (GSVector4i)r->FBA).alltrue()) if(PRIM->CTXT == i && !((GSVector4i)r->FBA).eq(m_env.CTXT[i].FBA))
{ {
Flush(); Flush();
} }
@ -835,7 +788,7 @@ template<int i> void GSState::GIFRegHandlerFBA(GIFReg* r)
template<int i> void GSState::GIFRegHandlerFRAME(GIFReg* r) template<int i> void GSState::GIFRegHandlerFRAME(GIFReg* r)
{ {
if(PRIM->CTXT == i && !(m_env.CTXT[i].FRAME == (GSVector4i)r->FRAME).alltrue()) if(PRIM->CTXT == i && !((GSVector4i)r->FRAME).eq(m_env.CTXT[i].FRAME))
{ {
Flush(); Flush();
} }
@ -845,7 +798,7 @@ template<int i> void GSState::GIFRegHandlerFRAME(GIFReg* r)
template<int i> void GSState::GIFRegHandlerZBUF(GIFReg* r) template<int i> void GSState::GIFRegHandlerZBUF(GIFReg* r)
{ {
if(r->ZBUF.ai32[0] == 0) if(r->ZBUF.u32[0] == 0)
{ {
// during startup all regs are cleared to 0 (by the bios or something), so we mask z until this register becomes valid // during startup all regs are cleared to 0 (by the bios or something), so we mask z until this register becomes valid
@ -854,7 +807,7 @@ template<int i> void GSState::GIFRegHandlerZBUF(GIFReg* r)
r->ZBUF.PSM |= 0x30; r->ZBUF.PSM |= 0x30;
if(PRIM->CTXT == i && !(m_env.CTXT[i].ZBUF == (GSVector4i)r->ZBUF).alltrue()) if(PRIM->CTXT == i && !((GSVector4i)r->ZBUF).eq(m_env.CTXT[i].ZBUF))
{ {
Flush(); Flush();
} }
@ -872,7 +825,7 @@ template<int i> void GSState::GIFRegHandlerZBUF(GIFReg* r)
void GSState::GIFRegHandlerBITBLTBUF(GIFReg* r) void GSState::GIFRegHandlerBITBLTBUF(GIFReg* r)
{ {
if(!(m_env.BITBLTBUF == (GSVector4i)r->BITBLTBUF).alltrue()) if(!((GSVector4i)r->BITBLTBUF).eq(m_env.BITBLTBUF))
{ {
FlushWrite(); FlushWrite();
} }
@ -892,7 +845,7 @@ void GSState::GIFRegHandlerBITBLTBUF(GIFReg* r)
void GSState::GIFRegHandlerTRXPOS(GIFReg* r) void GSState::GIFRegHandlerTRXPOS(GIFReg* r)
{ {
if(!(m_env.TRXPOS == (GSVector4i)r->TRXPOS).alltrue()) if(!((GSVector4i)r->TRXPOS).eq(m_env.TRXPOS))
{ {
FlushWrite(); FlushWrite();
} }
@ -902,7 +855,7 @@ void GSState::GIFRegHandlerTRXPOS(GIFReg* r)
void GSState::GIFRegHandlerTRXREG(GIFReg* r) void GSState::GIFRegHandlerTRXREG(GIFReg* r)
{ {
if(!(m_env.TRXREG == (GSVector4i)r->TRXREG).alltrue()) if(!((GSVector4i)r->TRXREG).eq(m_env.TRXREG))
{ {
FlushWrite(); FlushWrite();
} }
@ -937,7 +890,7 @@ void GSState::GIFRegHandlerHWREG(GIFReg* r)
{ {
ASSERT(m_env.TRXDIR.XDIR == 0); // host => local ASSERT(m_env.TRXDIR.XDIR == 0); // host => local
Write((BYTE*)r, 8); // hunting ground Write((uint8*)r, 8); // hunting ground
} }
void GSState::GIFRegHandlerSIGNAL(GIFReg* r) void GSState::GIFRegHandlerSIGNAL(GIFReg* r)
@ -990,7 +943,7 @@ void GSState::FlushWrite()
m_perfmon.Put(GSPerfMon::Swizzle, len); m_perfmon.Put(GSPerfMon::Swizzle, len);
CRect r; GSVector4i r;
r.left = m_env.TRXPOS.DSAX; r.left = m_env.TRXPOS.DSAX;
r.top = y; r.top = y;
@ -1010,7 +963,7 @@ void GSState::FlushWrite()
// //
void GSState::Write(BYTE* mem, int len) void GSState::Write(uint8* mem, int len)
{ {
int dx = m_env.TRXPOS.DSAX; int dx = m_env.TRXPOS.DSAX;
int dy = m_env.TRXPOS.DSAY; int dy = m_env.TRXPOS.DSAY;
@ -1041,7 +994,7 @@ void GSState::Write(BYTE* mem, int len)
m_mem.m_clut.Invalidate(); m_mem.m_clut.Invalidate();
} }
void GSState::Read(BYTE* mem, int len) void GSState::Read(uint8* mem, int len)
{ {
if(len <= 0) return; if(len <= 0) return;
@ -1059,7 +1012,7 @@ void GSState::Read(BYTE* mem, int len)
if(m_tr.x == sx && m_tr.y == sy) if(m_tr.x == sx && m_tr.y == sy)
{ {
InvalidateLocalMem(m_env.BITBLTBUF, CRect(CPoint(sx, sy), CSize(w, h))); InvalidateLocalMem(m_env.BITBLTBUF, GSVector4i(sx, sy, sx + w, sy + h));
} }
m_mem.ReadImageX(m_tr.x, m_tr.y, mem, len, m_env.BITBLTBUF, m_env.TRXPOS, m_env.TRXREG); m_mem.ReadImageX(m_tr.x, m_tr.y, mem, len, m_env.BITBLTBUF, m_env.TRXPOS, m_env.TRXREG);
@ -1077,8 +1030,8 @@ void GSState::Move()
int w = m_env.TRXREG.RRW; int w = m_env.TRXREG.RRW;
int h = m_env.TRXREG.RRH; int h = m_env.TRXREG.RRH;
InvalidateLocalMem(m_env.BITBLTBUF, CRect(CPoint(sx, sy), CSize(w, h))); InvalidateLocalMem(m_env.BITBLTBUF, GSVector4i(sx, sy, sx + w, sy + h));
InvalidateVideoMem(m_env.BITBLTBUF, CRect(CPoint(dx, dy), CSize(w, h))); InvalidateVideoMem(m_env.BITBLTBUF, GSVector4i(dx, dy, dx + w, dy + h));
int xinc = 1; int xinc = 1;
int yinc = 1; int yinc = 1;
@ -1102,10 +1055,10 @@ void GSState::Move()
{ {
for(int y = 0; y < h; y++, sy += yinc, dy += yinc, sx -= xinc * w, dx -= xinc * w) for(int y = 0; y < h; y++, sy += yinc, dy += yinc, sx -= xinc * w, dx -= xinc * w)
{ {
DWORD sbase = spsm.pa(0, sy, m_env.BITBLTBUF.SBP, m_env.BITBLTBUF.SBW); uint32 sbase = spsm.pa(0, sy, m_env.BITBLTBUF.SBP, m_env.BITBLTBUF.SBW);
int* soffset = spsm.rowOffset[sy & 7]; int* soffset = spsm.rowOffset[sy & 7];
DWORD dbase = dpsm.pa(0, dy, m_env.BITBLTBUF.DBP, m_env.BITBLTBUF.DBW); uint32 dbase = dpsm.pa(0, dy, m_env.BITBLTBUF.DBP, m_env.BITBLTBUF.DBW);
int* doffset = dpsm.rowOffset[dy & 7]; int* doffset = dpsm.rowOffset[dy & 7];
for(int x = 0; x < w; x++, sx += xinc, dx += xinc) for(int x = 0; x < w; x++, sx += xinc, dx += xinc)
@ -1118,10 +1071,10 @@ void GSState::Move()
{ {
for(int y = 0; y < h; y++, sy += yinc, dy += yinc, sx -= xinc * w, dx -= xinc * w) for(int y = 0; y < h; y++, sy += yinc, dy += yinc, sx -= xinc * w, dx -= xinc * w)
{ {
DWORD sbase = spsm.pa(0, sy, m_env.BITBLTBUF.SBP, m_env.BITBLTBUF.SBW); uint32 sbase = spsm.pa(0, sy, m_env.BITBLTBUF.SBP, m_env.BITBLTBUF.SBW);
int* soffset = spsm.rowOffset[sy & 7]; int* soffset = spsm.rowOffset[sy & 7];
DWORD dbase = dpsm.pa(0, dy, m_env.BITBLTBUF.DBP, m_env.BITBLTBUF.DBW); uint32 dbase = dpsm.pa(0, dy, m_env.BITBLTBUF.DBP, m_env.BITBLTBUF.DBW);
int* doffset = dpsm.rowOffset[dy & 7]; int* doffset = dpsm.rowOffset[dy & 7];
for(int x = 0; x < w; x++, sx += xinc, dx += xinc) for(int x = 0; x < w; x++, sx += xinc, dx += xinc)
@ -1132,7 +1085,7 @@ void GSState::Move()
} }
} }
void GSState::SoftReset(BYTE mask) void GSState::SoftReset(uint32 mask)
{ {
if(mask & 1) memset(&m_path[0], 0, sizeof(GIFPath)); if(mask & 1) memset(&m_path[0], 0, sizeof(GIFPath));
if(mask & 2) memset(&m_path[1], 0, sizeof(GIFPath)); if(mask & 2) memset(&m_path[1], 0, sizeof(GIFPath));
@ -1143,7 +1096,7 @@ void GSState::SoftReset(BYTE mask)
m_q = 1; m_q = 1;
} }
void GSState::ReadFIFO(BYTE* mem, int size) void GSState::ReadFIFO(uint8* mem, int size)
{ {
GSPerfMonAutoTimer pmat(m_perfmon); GSPerfMonAutoTimer pmat(m_perfmon);
@ -1159,15 +1112,15 @@ void GSState::ReadFIFO(BYTE* mem, int size)
} }
} }
template void GSState::Transfer<0>(BYTE* mem, UINT32 size); template void GSState::Transfer<0>(uint8* mem, uint32 size);
template void GSState::Transfer<1>(BYTE* mem, UINT32 size); template void GSState::Transfer<1>(uint8* mem, uint32 size);
template void GSState::Transfer<2>(BYTE* mem, UINT32 size); template void GSState::Transfer<2>(uint8* mem, uint32 size);
template<int index> void GSState::Transfer(BYTE* mem, UINT32 size) template<int index> void GSState::Transfer(uint8* mem, uint32 size)
{ {
GSPerfMonAutoTimer pmat(m_perfmon); GSPerfMonAutoTimer pmat(m_perfmon);
BYTE* start = mem; uint8* start = mem;
GIFPath& path = m_path[index]; GIFPath& path = m_path[index];
@ -1192,7 +1145,7 @@ template<int index> void GSState::Transfer(BYTE* mem, UINT32 size)
if(path.tag.PRE && (path.tag.FLG & 2) == 0) if(path.tag.PRE && (path.tag.FLG & 2) == 0)
{ {
GIFReg r; GIFReg r;
r.i64 = path.tag.PRIM; r.u64 = path.tag.PRIM;
(this->*m_fpGIFRegHandlers[GIF_A_D_REG_PRIM])(&r); (this->*m_fpGIFRegHandlers[GIF_A_D_REG_PRIM])(&r);
} }
} }
@ -1211,7 +1164,7 @@ template<int index> void GSState::Transfer(BYTE* mem, UINT32 size)
do do
{ {
(this->*m_fpGIFRegHandlers[(BYTE)((GIFPackedReg*)mem)->A_D.ADDR])(&((GIFPackedReg*)mem)->r); (this->*m_fpGIFRegHandlers[((GIFPackedReg*)mem)->A_D.ADDR])(&((GIFPackedReg*)mem)->r);
mem += sizeof(GIFPackedReg); mem += sizeof(GIFPackedReg);
} }
@ -1221,7 +1174,7 @@ template<int index> void GSState::Transfer(BYTE* mem, UINT32 size)
{ {
do do
{ {
DWORD reg = path.GetReg(); uint32 reg = path.GetReg();
switch(reg) switch(reg)
{ {
@ -1343,13 +1296,13 @@ template<int index> void GSState::Transfer(BYTE* mem, UINT32 size)
} }
} }
template<class T> static void WriteState(BYTE*& dst, T* src, size_t len = sizeof(T)) template<class T> static void WriteState(uint8*& dst, T* src, size_t len = sizeof(T))
{ {
memcpy(dst, src, len); memcpy(dst, src, len);
dst += len; dst += len;
} }
template<class T> static void ReadState(T* dst, BYTE*& src, size_t len = sizeof(T)) template<class T> static void ReadState(T* dst, uint8*& src, size_t len = sizeof(T))
{ {
memcpy(dst, src, len); memcpy(dst, src, len);
src += len; src += len;
@ -1370,7 +1323,7 @@ int GSState::Freeze(GSFreezeData* fd, bool sizeonly)
Flush(); Flush();
BYTE* data = fd->data; uint8* data = fd->data;
WriteState(data, &m_version); WriteState(data, &m_version);
WriteState(data, &m_env.PRIM); WriteState(data, &m_env.PRIM);
@ -1442,7 +1395,7 @@ int GSState::Defrost(const GSFreezeData* fd)
return -1; return -1;
} }
BYTE* data = fd->data; uint8* data = fd->data;
int version; int version;
@ -1495,7 +1448,7 @@ int GSState::Defrost(const GSFreezeData* fd)
if(version <= 4) if(version <= 4)
{ {
data += sizeof(DWORD) * 7; // skip data += sizeof(uint32) * 7; // skip
} }
} }
@ -1536,7 +1489,7 @@ m_perfmon.SetFrame(5000);
return 0; return 0;
} }
void GSState::SetGameCRC(DWORD crc, int options) void GSState::SetGameCRC(uint32 crc, int options)
{ {
m_crc = crc; m_crc = crc;
m_options = options; m_options = options;
@ -1608,7 +1561,7 @@ GSState::GSTransferBuffer::GSTransferBuffer()
{ {
x = y = 0; x = y = 0;
start = end = total = 0; start = end = total = 0;
buff = (BYTE*)_aligned_malloc(1024 * 1024 * 4, 16); buff = (uint8*)_aligned_malloc(1024 * 1024 * 4, 16);
} }
GSState::GSTransferBuffer::~GSTransferBuffer() GSState::GSTransferBuffer::~GSTransferBuffer()
@ -1653,12 +1606,12 @@ bool GSState::GSTransferBuffer::Update(int tw, int th, int bpp, int& len)
struct GSFrameInfo struct GSFrameInfo
{ {
DWORD FBP; uint32 FBP;
DWORD FPSM; uint32 FPSM;
DWORD FBMSK; uint32 FBMSK;
uint32 TBP0;
uint32 TPSM;
bool TME; bool TME;
DWORD TBP0;
DWORD TPSM;
}; };
typedef bool (*GetSkipCount)(const GSFrameInfo& fi, int& skip); typedef bool (*GetSkipCount)(const GSFrameInfo& fi, int& skip);

47
plugins/GSdx/GSState.h
View File

@ -117,7 +117,7 @@ class GSState : public GSAlignedClass<16>
int x, y; int x, y;
int start, end, total; int start, end, total;
bool overflow; bool overflow;
BYTE* buff; uint8* buff;
GSTransferBuffer(); GSTransferBuffer();
virtual ~GSTransferBuffer(); virtual ~GSTransferBuffer();
@ -204,58 +204,49 @@ public:
GSDrawingContext* m_context; GSDrawingContext* m_context;
GSVertex m_v; GSVertex m_v;
float m_q; float m_q;
DWORD m_vprim; uint32 m_vprim;
GSPerfMon m_perfmon; GSPerfMon m_perfmon;
DWORD m_crc; uint32 m_crc;
int m_options; int m_options;
int m_frameskip; int m_frameskip;
CRC::Game m_game; CRC::Game m_game;
GSDump m_dump; GSDump m_dump;
public: public:
GSState(BYTE* base, bool mt, void (*irq)()); GSState(uint8* base, bool mt, void (*irq)());
virtual ~GSState(); virtual ~GSState();
void ResetHandlers(); void ResetHandlers();
CPoint GetDisplayPos(int i); GSVector4i GetDisplayRect(int i = -1);
CSize GetDisplaySize(int i); GSVector4i GetFrameRect(int i = -1);
CRect GetDisplayRect(int i); GSVector4i GetDeviceRect(int i = -1);
CSize GetDisplayPos();
CSize GetDisplaySize();
CRect GetDisplayRect();
CPoint GetFramePos(int i);
CSize GetFrameSize(int i);
CRect GetFrameRect(int i);
CSize GetFramePos();
CSize GetFrameSize();
CRect GetFrameRect();
CSize GetDeviceSize(int i);
CSize GetDeviceSize();
bool IsEnabled(int i); bool IsEnabled(int i);
int GetFPS(); int GetFPS();
virtual void Reset(); virtual void Reset();
virtual void Flush(); virtual void Flush();
virtual void FlushPrim() = 0; virtual void FlushPrim() = 0;
virtual void ResetPrim() = 0; virtual void ResetPrim() = 0;
virtual void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, CRect r) {} virtual void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& r) {}
virtual void InvalidateLocalMem(const GIFRegBITBLTBUF& BITBLTBUF, CRect r) {} virtual void InvalidateLocalMem(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& r) {}
virtual void InvalidateTextureCache() {} virtual void InvalidateTextureCache() {}
void Move(); void Move();
void Write(BYTE* mem, int len); void Write(uint8* mem, int len);
void Read(BYTE* mem, int len); void Read(uint8* mem, int len);
void SoftReset(BYTE mask); void SoftReset(uint32 mask);
void WriteCSR(UINT32 csr) {m_regs->CSR.ai32[1] = csr;} void WriteCSR(uint32 csr) {m_regs->CSR.u32[1] = csr;}
void ReadFIFO(BYTE* mem, int size); void ReadFIFO(uint8* mem, int size);
template<int index> void Transfer(BYTE* mem, UINT32 size); template<int index> void Transfer(uint8* mem, uint32 size);
int Freeze(GSFreezeData* fd, bool sizeonly); int Freeze(GSFreezeData* fd, bool sizeonly);
int Defrost(const GSFreezeData* fd); int Defrost(const GSFreezeData* fd);
void GetLastTag(UINT32* tag) {*tag = m_path3hack; m_path3hack = 0;} void GetLastTag(uint32* tag) {*tag = m_path3hack; m_path3hack = 0;}
virtual void SetGameCRC(DWORD crc, int options); virtual void SetGameCRC(uint32 crc, int options);
void SetFrameSkip(int frameskip); void SetFrameSkip(int frameskip);
}; };

32
plugins/GSdx/GSTables.cpp
View File

@ -22,21 +22,21 @@
#include "StdAfx.h" #include "StdAfx.h"
#include "GSTables.h" #include "GSTables.h"
const BYTE blockTable32[4][8] = { const uint8 blockTable32[4][8] = {
{ 0, 1, 4, 5, 16, 17, 20, 21}, { 0, 1, 4, 5, 16, 17, 20, 21},
{ 2, 3, 6, 7, 18, 19, 22, 23}, { 2, 3, 6, 7, 18, 19, 22, 23},
{ 8, 9, 12, 13, 24, 25, 28, 29}, { 8, 9, 12, 13, 24, 25, 28, 29},
{ 10, 11, 14, 15, 26, 27, 30, 31} { 10, 11, 14, 15, 26, 27, 30, 31}
}; };
const BYTE blockTable32Z[4][8] = { const uint8 blockTable32Z[4][8] = {
{ 24, 25, 28, 29, 8, 9, 12, 13}, { 24, 25, 28, 29, 8, 9, 12, 13},
{ 26, 27, 30, 31, 10, 11, 14, 15}, { 26, 27, 30, 31, 10, 11, 14, 15},
{ 16, 17, 20, 21, 0, 1, 4, 5}, { 16, 17, 20, 21, 0, 1, 4, 5},
{ 18, 19, 22, 23, 2, 3, 6, 7} { 18, 19, 22, 23, 2, 3, 6, 7}
}; };
const BYTE blockTable16[8][4] = { const uint8 blockTable16[8][4] = {
{ 0, 2, 8, 10 }, { 0, 2, 8, 10 },
{ 1, 3, 9, 11 }, { 1, 3, 9, 11 },
{ 4, 6, 12, 14 }, { 4, 6, 12, 14 },
@ -47,7 +47,7 @@ const BYTE blockTable16[8][4] = {
{ 21, 23, 29, 31 } { 21, 23, 29, 31 }
}; };
const BYTE blockTable16S[8][4] = { const uint8 blockTable16S[8][4] = {
{ 0, 2, 16, 18 }, { 0, 2, 16, 18 },
{ 1, 3, 17, 19 }, { 1, 3, 17, 19 },
{ 8, 10, 24, 26 }, { 8, 10, 24, 26 },
@ -58,7 +58,7 @@ const BYTE blockTable16S[8][4] = {
{ 13, 15, 29, 31 } { 13, 15, 29, 31 }
}; };
const BYTE blockTable16Z[8][4] = { const uint8 blockTable16Z[8][4] = {
{ 24, 26, 16, 18 }, { 24, 26, 16, 18 },
{ 25, 27, 17, 19 }, { 25, 27, 17, 19 },
{ 28, 30, 20, 22 }, { 28, 30, 20, 22 },
@ -69,7 +69,7 @@ const BYTE blockTable16Z[8][4] = {
{ 13, 15, 5, 7 } { 13, 15, 5, 7 }
}; };
const BYTE blockTable16SZ[8][4] = { const uint8 blockTable16SZ[8][4] = {
{ 24, 26, 8, 10 }, { 24, 26, 8, 10 },
{ 25, 27, 9, 11 }, { 25, 27, 9, 11 },
{ 16, 18, 0, 2 }, { 16, 18, 0, 2 },
@ -80,14 +80,14 @@ const BYTE blockTable16SZ[8][4] = {
{ 21, 23, 5, 7 } { 21, 23, 5, 7 }
}; };
const BYTE blockTable8[4][8] = { const uint8 blockTable8[4][8] = {
{ 0, 1, 4, 5, 16, 17, 20, 21}, { 0, 1, 4, 5, 16, 17, 20, 21},
{ 2, 3, 6, 7, 18, 19, 22, 23}, { 2, 3, 6, 7, 18, 19, 22, 23},
{ 8, 9, 12, 13, 24, 25, 28, 29}, { 8, 9, 12, 13, 24, 25, 28, 29},
{ 10, 11, 14, 15, 26, 27, 30, 31} { 10, 11, 14, 15, 26, 27, 30, 31}
}; };
const BYTE blockTable4[8][4] = { const uint8 blockTable4[8][4] = {
{ 0, 2, 8, 10 }, { 0, 2, 8, 10 },
{ 1, 3, 9, 11 }, { 1, 3, 9, 11 },
{ 4, 6, 12, 14 }, { 4, 6, 12, 14 },
@ -98,7 +98,7 @@ const BYTE blockTable4[8][4] = {
{ 21, 23, 29, 31 } { 21, 23, 29, 31 }
}; };
const BYTE columnTable32[8][8] = { const uint8 columnTable32[8][8] = {
{ 0, 1, 4, 5, 8, 9, 12, 13 }, { 0, 1, 4, 5, 8, 9, 12, 13 },
{ 2, 3, 6, 7, 10, 11, 14, 15 }, { 2, 3, 6, 7, 10, 11, 14, 15 },
{ 16, 17, 20, 21, 24, 25, 28, 29 }, { 16, 17, 20, 21, 24, 25, 28, 29 },
@ -109,7 +109,7 @@ const BYTE columnTable32[8][8] = {
{ 50, 51, 54, 55, 58, 59, 62, 63 }, { 50, 51, 54, 55, 58, 59, 62, 63 },
}; };
const BYTE columnTable16[8][16] = { const uint8 columnTable16[8][16] = {
{ 0, 2, 8, 10, 16, 18, 24, 26, { 0, 2, 8, 10, 16, 18, 24, 26,
1, 3, 9, 11, 17, 19, 25, 27 }, 1, 3, 9, 11, 17, 19, 25, 27 },
{ 4, 6, 12, 14, 20, 22, 28, 30, { 4, 6, 12, 14, 20, 22, 28, 30,
@ -128,7 +128,7 @@ const BYTE columnTable16[8][16] = {
101, 103, 109, 111, 117, 119, 125, 127 }, 101, 103, 109, 111, 117, 119, 125, 127 },
}; };
const BYTE columnTable8[16][16] = { const uint8 columnTable8[16][16] = {
{ 0, 4, 16, 20, 32, 36, 48, 52, // column 0 { 0, 4, 16, 20, 32, 36, 48, 52, // column 0
2, 6, 18, 22, 34, 38, 50, 54 }, 2, 6, 18, 22, 34, 38, 50, 54 },
{ 8, 12, 24, 28, 40, 44, 56, 60, { 8, 12, 24, 28, 40, 44, 56, 60,
@ -163,7 +163,7 @@ const BYTE columnTable8[16][16] = {
203, 207, 219, 223, 235, 239, 251, 255 }, 203, 207, 219, 223, 235, 239, 251, 255 },
}; };
const WORD columnTable4[16][32] = { const uint16 columnTable4[16][32] = {
{ 0, 8, 32, 40, 64, 72, 96, 104, // column 0 { 0, 8, 32, 40, 64, 72, 96, 104, // column 0
2, 10, 34, 42, 66, 74, 98, 106, 2, 10, 34, 42, 66, 74, 98, 106,
4, 12, 36, 44, 68, 76, 100, 108, 4, 12, 36, 44, 68, 76, 100, 108,
@ -230,7 +230,7 @@ const WORD columnTable4[16][32] = {
407, 415, 439, 447, 471, 479, 503, 511 }, 407, 415, 439, 447, 471, 479, 503, 511 },
}; };
const BYTE clutTableT32I8[128] = const uint8 clutTableT32I8[128] =
{ {
0, 1, 4, 5, 8, 9, 12, 13, 2, 3, 6, 7, 10, 11, 14, 15, 0, 1, 4, 5, 8, 9, 12, 13, 2, 3, 6, 7, 10, 11, 14, 15,
64, 65, 68, 69, 72, 73, 76, 77, 66, 67, 70, 71, 74, 75, 78, 79, 64, 65, 68, 69, 72, 73, 76, 77, 66, 67, 70, 71, 74, 75, 78, 79,
@ -242,13 +242,13 @@ const BYTE clutTableT32I8[128] =
112, 113, 116, 117, 120, 121, 124, 125, 114, 115, 118, 119, 122, 123, 126, 127 112, 113, 116, 117, 120, 121, 124, 125, 114, 115, 118, 119, 122, 123, 126, 127
}; };
const BYTE clutTableT32I4[16] = const uint8 clutTableT32I4[16] =
{ {
0, 1, 4, 5, 8, 9, 12, 13, 0, 1, 4, 5, 8, 9, 12, 13,
2, 3, 6, 7, 10, 11, 14, 15 2, 3, 6, 7, 10, 11, 14, 15
}; };
const BYTE clutTableT16I8[32] = const uint8 clutTableT16I8[32] =
{ {
0, 2, 8, 10, 16, 18, 24, 26, 0, 2, 8, 10, 16, 18, 24, 26,
4, 6, 12, 14, 20, 22, 28, 30, 4, 6, 12, 14, 20, 22, 28, 30,
@ -256,7 +256,7 @@ const BYTE clutTableT16I8[32] =
5, 7, 13, 15, 21, 23, 29, 31 5, 7, 13, 15, 21, 23, 29, 31
}; };
const BYTE clutTableT16I4[16] = const uint8 clutTableT16I4[16] =
{ {
0, 2, 8, 10, 16, 18, 24, 26, 0, 2, 8, 10, 16, 18, 24, 26,
4, 6, 12, 14, 20, 22, 28, 30 4, 6, 12, 14, 20, 22, 28, 30

32
plugins/GSdx/GSTables.h
View File

@ -21,19 +21,19 @@
#pragma once #pragma once
extern const BYTE blockTable32[4][8]; extern const uint8 blockTable32[4][8];
extern const BYTE blockTable32Z[4][8]; extern const uint8 blockTable32Z[4][8];
extern const BYTE blockTable16[8][4]; extern const uint8 blockTable16[8][4];
extern const BYTE blockTable16S[8][4]; extern const uint8 blockTable16S[8][4];
extern const BYTE blockTable16Z[8][4]; extern const uint8 blockTable16Z[8][4];
extern const BYTE blockTable16SZ[8][4]; extern const uint8 blockTable16SZ[8][4];
extern const BYTE blockTable8[4][8]; extern const uint8 blockTable8[4][8];
extern const BYTE blockTable4[8][4]; extern const uint8 blockTable4[8][4];
extern const BYTE columnTable32[8][8]; extern const uint8 columnTable32[8][8];
extern const BYTE columnTable16[8][16]; extern const uint8 columnTable16[8][16];
extern const BYTE columnTable8[16][16]; extern const uint8 columnTable8[16][16];
extern const WORD columnTable4[16][32]; extern const uint16 columnTable4[16][32];
extern const BYTE clutTableT32I8[128]; extern const uint8 clutTableT32I8[128];
extern const BYTE clutTableT32I4[16]; extern const uint8 clutTableT32I4[16];
extern const BYTE clutTableT16I8[32]; extern const uint8 clutTableT16I8[32];
extern const BYTE clutTableT16I4[16]; extern const uint8 clutTableT16I4[16];

6
plugins/GSdx/GSTexture.h
View File

@ -39,10 +39,10 @@ public:
virtual int GetWidth() const = 0; virtual int GetWidth() const = 0;
virtual int GetHeight() const = 0; virtual int GetHeight() const = 0;
virtual int GetFormat() const = 0; virtual int GetFormat() const = 0;
virtual bool Update(const CRect& r, const void* data, int pitch) = 0; virtual bool Update(const GSVector4i& r, const void* data, int pitch) = 0;
virtual bool Map(BYTE** bits, int& pitch, const RECT* r = NULL) = 0; virtual bool Map(uint8** bits, int& pitch) = 0;
virtual void Unmap() = 0; virtual void Unmap() = 0;
virtual bool Save(const string& fn, bool dds = false) = 0; virtual bool Save(const string& fn, bool dds = false) = 0;
CSize GetSize() {return CSize(GetWidth(), GetHeight());} GSVector2i GetSize() {return GSVector2i(GetWidth(), GetHeight());}
}; };

16
plugins/GSdx/GSTexture10.cpp
View File

@ -69,7 +69,7 @@ int GSTexture10::GetFormat() const
return m_desc.Format; return m_desc.Format;
} }
bool GSTexture10::Update(const CRect& r, const void* data, int pitch) bool GSTexture10::Update(const GSVector4i& r, const void* data, int pitch)
{ {
if(m_dev && m_texture) if(m_dev && m_texture)
{ {
@ -83,7 +83,7 @@ bool GSTexture10::Update(const CRect& r, const void* data, int pitch)
return false; return false;
} }
bool GSTexture10::Map(BYTE** bits, int& pitch, const RECT* r) bool GSTexture10::Map(uint8** bits, int& pitch)
{ {
if(m_texture) if(m_texture)
{ {
@ -91,7 +91,7 @@ bool GSTexture10::Map(BYTE** bits, int& pitch, const RECT* r)
if(SUCCEEDED(m_texture->Map(0, D3D10_MAP_READ_WRITE, 0, &map))) if(SUCCEEDED(m_texture->Map(0, D3D10_MAP_READ_WRITE, 0, &map)))
{ {
*bits = (BYTE*)map.pData; *bits = (uint8*)map.pData;
pitch = (int)map.RowPitch; pitch = (int)map.RowPitch;
return true; return true;
@ -143,14 +143,14 @@ bool GSTexture10::Save(const string& fn, bool dds)
hr = src->Map(0, D3D10_MAP_READ, 0, &sm); hr = src->Map(0, D3D10_MAP_READ, 0, &sm);
hr = dst->Map(0, D3D10_MAP_WRITE, 0, &dm); hr = dst->Map(0, D3D10_MAP_WRITE, 0, &dm);
BYTE* s = (BYTE*)sm.pData; uint8* s = (uint8*)sm.pData;
BYTE* d = (BYTE*)dm.pData; uint8* d = (uint8*)dm.pData;
for(UINT y = 0; y < desc.Height; y++, s += sm.RowPitch, d += dm.RowPitch) for(uint32 y = 0; y < desc.Height; y++, s += sm.RowPitch, d += dm.RowPitch)
{ {
for(UINT x = 0; x < desc.Width; x++) for(uint32 x = 0; x < desc.Width; x++)
{ {
((UINT*)d)[x] = (UINT)(((float*)s)[x*2] * UINT_MAX); ((uint32*)d)[x] = (uint32)(((float*)s)[x*2] * UINT_MAX);
} }
} }

4
plugins/GSdx/GSTexture10.h
View File

@ -43,8 +43,8 @@ public:
int GetWidth() const; int GetWidth() const;
int GetHeight() const; int GetHeight() const;
int GetFormat() const; int GetFormat() const;
bool Update(const CRect& r, const void* data, int pitch); bool Update(const GSVector4i& r, const void* data, int pitch);
bool Map(BYTE** bits, int& pitch, const RECT* r = NULL); bool Map(uint8** bits, int& pitch);
void Unmap(); void Unmap();
bool Save(const string& fn, bool dds = false); bool Save(const string& fn, bool dds = false);

28
plugins/GSdx/GSTexture7.cpp
View File

@ -80,11 +80,11 @@ int GSTexture7::GetFormat() const
return (int)m_desc.ddpfPixelFormat.dwFourCC; return (int)m_desc.ddpfPixelFormat.dwFourCC;
} }
bool GSTexture7::Update(const CRect& r, const void* data, int pitch) bool GSTexture7::Update(const GSVector4i& r, const void* data, int pitch)
{ {
HRESULT hr; HRESULT hr;
CRect r2 = r; GSVector4i r2 = r;
DDSURFACEDESC2 desc; DDSURFACEDESC2 desc;
@ -92,14 +92,14 @@ bool GSTexture7::Update(const CRect& r, const void* data, int pitch)
desc.dwSize = sizeof(desc); desc.dwSize = sizeof(desc);
if(SUCCEEDED(hr = m_system->Lock(&r2, &desc, DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR | DDLOCK_WRITEONLY, NULL))) if(SUCCEEDED(hr = m_system->Lock(r2, &desc, DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR | DDLOCK_WRITEONLY, NULL)))
{ {
BYTE* src = (BYTE*)data; uint8* src = (uint8*)data;
BYTE* dst = (BYTE*)desc.lpSurface; uint8* dst = (uint8*)desc.lpSurface;
int bytes = min(pitch, desc.lPitch); int bytes = min(pitch, desc.lPitch);
for(int i = 0, j = r.Height(); i < j; i++, src += pitch, dst += desc.lPitch) for(int i = 0, j = r.height(); i < j; i++, src += pitch, dst += desc.lPitch)
{ {
// memcpy(dst, src, bytes); // memcpy(dst, src, bytes);
@ -120,11 +120,11 @@ bool GSTexture7::Update(const CRect& r, const void* data, int pitch)
} }
} }
hr = m_system->Unlock(&r2); hr = m_system->Unlock(r2);
if(m_video) if(m_video)
{ {
hr = m_video->Blt(&r2, m_system, &r2, DDBLT_WAIT, NULL); hr = m_video->Blt(r2, m_system, r2, DDBLT_WAIT, NULL);
} }
return true; return true;
@ -133,21 +133,17 @@ bool GSTexture7::Update(const CRect& r, const void* data, int pitch)
return false; return false;
} }
bool GSTexture7::Map(BYTE** bits, int& pitch, const RECT* r) bool GSTexture7::Map(uint8** bits, int& pitch)
{ {
HRESULT hr; HRESULT hr;
CRect r2 = r;
DDSURFACEDESC2 desc; DDSURFACEDESC2 desc;
if(SUCCEEDED(hr = m_system->Lock(&r2, &desc, DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR, NULL))) if(SUCCEEDED(hr = m_system->Lock(NULL, &desc, DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR, NULL)))
{ {
*bits = (BYTE*)desc.lpSurface; *bits = (uint8*)desc.lpSurface;
pitch = (int)desc.lPitch; pitch = (int)desc.lPitch;
m_lr = r;
return true; return true;
} }
@ -162,7 +158,7 @@ void GSTexture7::Unmap()
if(m_video) if(m_video)
{ {
hr = m_video->Blt(&m_lr, m_system, &m_lr, DDBLT_WAIT, NULL); hr = m_video->Blt(NULL, m_system, NULL, DDBLT_WAIT, NULL);
} }
} }

5
plugins/GSdx/GSTexture7.h
View File

@ -30,7 +30,6 @@ class GSTexture7 : public GSTexture
CComPtr<IDirectDrawSurface7> m_system; CComPtr<IDirectDrawSurface7> m_system;
CComPtr<IDirectDrawSurface7> m_video; CComPtr<IDirectDrawSurface7> m_video;
DDSURFACEDESC2 m_desc; DDSURFACEDESC2 m_desc;
CRect m_lr;
public: public:
GSTexture7(); GSTexture7();
@ -44,8 +43,8 @@ public:
int GetWidth() const; int GetWidth() const;
int GetHeight() const; int GetHeight() const;
int GetFormat() const; int GetFormat() const;
bool Update(const CRect& r, const void* data, int pitch); bool Update(const GSVector4i& r, const void* data, int pitch);
bool Map(BYTE** bits, int& pitch, const RECT* r = NULL); bool Map(uint8** bits, int& pitch);
void Unmap(); void Unmap();
bool Save(const string& fn, bool dds = false); bool Save(const string& fn, bool dds = false);

22
plugins/GSdx/GSTexture9.cpp
View File

@ -83,7 +83,7 @@ int GSTexture9::GetFormat() const
return m_desc.Format; return m_desc.Format;
} }
bool GSTexture9::Update(const CRect& r, const void* data, int pitch) bool GSTexture9::Update(const GSVector4i& r, const void* data, int pitch)
{ {
if(CComPtr<IDirect3DSurface9> surface = *this) if(CComPtr<IDirect3DSurface9> surface = *this)
{ {
@ -91,12 +91,12 @@ bool GSTexture9::Update(const CRect& r, const void* data, int pitch)
if(SUCCEEDED(surface->LockRect(&lr, r, 0))) if(SUCCEEDED(surface->LockRect(&lr, r, 0)))
{ {
BYTE* src = (BYTE*)data; uint8* src = (uint8*)data;
BYTE* dst = (BYTE*)lr.pBits; uint8* dst = (uint8*)lr.pBits;
int bytes = min(pitch, lr.Pitch); int bytes = min(pitch, lr.Pitch);
for(int i = 0, j = r.Height(); i < j; i++, src += pitch, dst += lr.Pitch) for(int i = 0, j = r.height(); i < j; i++, src += pitch, dst += lr.Pitch)
{ {
memcpy(dst, src, bytes); memcpy(dst, src, bytes);
} }
@ -110,7 +110,7 @@ bool GSTexture9::Update(const CRect& r, const void* data, int pitch)
return false; return false;
} }
bool GSTexture9::Map(BYTE** bits, int& pitch, const RECT* r) bool GSTexture9::Map(uint8** bits, int& pitch)
{ {
HRESULT hr; HRESULT hr;
@ -118,9 +118,9 @@ bool GSTexture9::Map(BYTE** bits, int& pitch, const RECT* r)
{ {
D3DLOCKED_RECT lr; D3DLOCKED_RECT lr;
if(SUCCEEDED(hr = surface->LockRect(&lr, r, 0))) if(SUCCEEDED(hr = surface->LockRect(&lr, NULL, 0)))
{ {
*bits = (BYTE*)lr.pBits; *bits = (uint8*)lr.pBits;
pitch = (int)lr.Pitch; pitch = (int)lr.Pitch;
return true; return true;
@ -160,12 +160,12 @@ bool GSTexture9::Save(const string& fn, bool dds)
hr = m_surface->LockRect(&slr, NULL, 0); hr = m_surface->LockRect(&slr, NULL, 0);
hr = surface->LockRect(&dlr, NULL, 0); hr = surface->LockRect(&dlr, NULL, 0);
BYTE* s = (BYTE*)slr.pBits; uint8* s = (uint8*)slr.pBits;
BYTE* d = (BYTE*)dlr.pBits; uint8* d = (uint8*)dlr.pBits;
for(UINT y = 0; y < desc.Height; y++, s += slr.Pitch, d += dlr.Pitch) for(uint32 y = 0; y < desc.Height; y++, s += slr.Pitch, d += dlr.Pitch)
{ {
for(UINT x = 0; x < desc.Width; x++) for(uint32 x = 0; x < desc.Width; x++)
{ {
((float*)d)[x] = ((float*)s)[x]; ((float*)d)[x] = ((float*)s)[x];
} }

4
plugins/GSdx/GSTexture9.h
View File

@ -42,8 +42,8 @@ public:
int GetWidth() const; int GetWidth() const;
int GetHeight() const; int GetHeight() const;
int GetFormat() const; int GetFormat() const;
bool Update(const CRect& r, const void* data, int pitch); bool Update(const GSVector4i& r, const void* data, int pitch);
bool Map(BYTE** bits, int& pitch, const RECT* r = NULL); bool Map(uint8** bits, int& pitch);
void Unmap(); void Unmap();
bool Save(const string& fn, bool dds = false); bool Save(const string& fn, bool dds = false);

135
plugins/GSdx/GSTextureCache.h
View File

@ -28,7 +28,7 @@ template<class Device> class GSTextureCache
typedef typename Device::Texture Texture; typedef typename Device::Texture Texture;
public: public:
class GSSurface class GSSurface : public GSAlignedClass<16>
{ {
protected: protected:
GSRenderer<Device>* m_renderer; GSRenderer<Device>* m_renderer;
@ -48,7 +48,7 @@ public:
, m_age(0) , m_age(0)
, m_initpalette(false) , m_initpalette(false)
{ {
m_TEX0.TBP0 = (UINT32)~0; m_TEX0.TBP0 = (uint32)~0;
} }
virtual ~GSSurface() virtual ~GSSurface()
@ -81,7 +81,7 @@ public:
return m_renderer->m_dev.CreateRenderTarget(m_texture, w, h); return m_renderer->m_dev.CreateRenderTarget(m_texture, w, h);
} }
virtual void Read(CRect r) = 0; virtual void Read(const GSVector4i& r) = 0;
}; };
class GSDepthStencil : public GSSurface class GSDepthStencil : public GSSurface
@ -107,30 +107,30 @@ public:
class GSTexture : public GSSurface class GSTexture : public GSSurface
{ {
protected: protected:
bool GetDirtyRect(CRect& rr) bool GetDirtyRect(GSVector4i& rr)
{ {
int w = 1 << m_TEX0.TW; int w = 1 << m_TEX0.TW;
int h = 1 << m_TEX0.TH; int h = 1 << m_TEX0.TH;
CRect r(0, 0, w, h); GSVector4i r(0, 0, w, h);
for(list<GSDirtyRect>::iterator i = m_dirty.begin(); i != m_dirty.end(); i++) for(list<GSDirtyRect>::iterator i = m_dirty.begin(); i != m_dirty.end(); i++)
{ {
const CRect& dirty = i->GetDirtyRect(m_TEX0) & r; const GSVector4i& dirty = i->GetDirtyRect(m_TEX0).rintersect(r);
if(!(m_valid & dirty).IsRectEmpty()) if(!m_valid.rintersect(dirty).rempty())
{ {
// find the rect having the largest area, outside dirty, inside m_valid // find the rect having the largest area, outside dirty, inside m_valid
CRect left(m_valid.left, m_valid.top, min(m_valid.right, dirty.left), m_valid.bottom); GSVector4i left(m_valid.left, m_valid.top, min(m_valid.right, dirty.left), m_valid.bottom);
CRect top(m_valid.left, m_valid.top, m_valid.right, min(m_valid.bottom, dirty.top)); GSVector4i top(m_valid.left, m_valid.top, m_valid.right, min(m_valid.bottom, dirty.top));
CRect right(max(m_valid.left, dirty.right), m_valid.top, m_valid.right, m_valid.bottom); GSVector4i right(max(m_valid.left, dirty.right), m_valid.top, m_valid.right, m_valid.bottom);
CRect bottom(m_valid.left, max(m_valid.top, dirty.bottom), m_valid.right, m_valid.bottom); GSVector4i bottom(m_valid.left, max(m_valid.top, dirty.bottom), m_valid.right, m_valid.bottom);
int leftsize = !left.IsRectEmpty() ? left.Width() * left.Height() : 0; int leftsize = !left.rempty() ? left.width() * left.height() : 0;
int topsize = !top.IsRectEmpty() ? top.Width() * top.Height() : 0; int topsize = !top.rempty() ? top.width() * top.height() : 0;
int rightsize = !right.IsRectEmpty() ? right.Width() * right.Height() : 0; int rightsize = !right.rempty() ? right.width() * right.height() : 0;
int bottomsize = !bottom.IsRectEmpty() ? bottom.Width() * bottom.Height() : 0; int bottomsize = !bottom.rempty() ? bottom.width() * bottom.height() : 0;
// TODO: sort // TODO: sort
@ -139,7 +139,7 @@ public:
topsize > 0 ? top : topsize > 0 ? top :
rightsize > 0 ? right : rightsize > 0 ? right :
bottomsize > 0 ? bottom : bottomsize > 0 ? bottom :
CRect(0, 0, 0, 0); GSVector4i::zero();
} }
} }
@ -167,10 +167,10 @@ public:
} }
else else
{ {
r |= m_valid; r = r.runion(m_valid);
} }
if(r.IsRectEmpty()) if(r.rempty())
{ {
return false; return false;
} }
@ -182,8 +182,8 @@ public:
public: public:
GIFRegCLAMP m_CLAMP; GIFRegCLAMP m_CLAMP;
DWORD* m_clut; // * uint32* m_clut; // *
CRect m_valid; GSVector4i m_valid;
int m_bpp; int m_bpp;
int m_bpp2; int m_bpp2;
bool m_rendered; bool m_rendered;
@ -195,7 +195,7 @@ public:
, m_bpp2(0) , m_bpp2(0)
, m_rendered(false) , m_rendered(false)
{ {
m_clut = (DWORD*)_aligned_malloc(256 * sizeof(DWORD), 16); m_clut = (uint32*)_aligned_malloc(256 * sizeof(uint32), 16);
memset(m_clut, 0, sizeof(m_clut)); memset(m_clut, 0, sizeof(m_clut));
} }
@ -205,6 +205,41 @@ public:
_aligned_free(m_clut); _aligned_free(m_clut);
} }
void Update()
{
__super::Update();
if(m_rendered)
{
return;
}
GSVector4i r;
if(!GetDirtyRect(r))
{
return;
}
m_valid = m_valid.runion(r);
static uint8* bits = (uint8*)::_aligned_malloc(1024 * 1024 * 4, 16);
static int pitch = 1024 * 4;
if(m_renderer->m_psrr)
{
m_renderer->m_mem.ReadTextureNPNC(r, bits, pitch, m_renderer->m_context->TEX0, m_renderer->m_env.TEXA, m_renderer->m_context->CLAMP);
}
else
{
m_renderer->m_mem.ReadTextureNP(r, bits, pitch, m_renderer->m_context->TEX0, m_renderer->m_env.TEXA, m_renderer->m_context->CLAMP);
}
m_texture.Update(r, bits, pitch);
m_renderer->m_perfmon.Put(GSPerfMon::Unswizzle, r.width() * r.height() * m_bpp >> 3);
}
virtual bool Create() = 0; virtual bool Create() = 0;
virtual bool Create(GSRenderTarget* rt) = 0; virtual bool Create(GSRenderTarget* rt) = 0;
virtual bool Create(GSDepthStencil* ds) = 0; virtual bool Create(GSDepthStencil* ds) = 0;
@ -335,10 +370,12 @@ public:
if(m_renderer->CanUpscale()) if(m_renderer->CanUpscale())
{ {
int ww = (int)(m_renderer->GetFramePos().cx + rt->m_TEX0.TBW * 64); GSVector4i fr = m_renderer->GetFrameRect();
int hh = (int)(m_renderer->GetFramePos().cy + m_renderer->GetDisplaySize().cy);
if(hh <= m_renderer->GetDeviceSize().cy / 2) int ww = (int)(fr.left + rt->m_TEX0.TBW * 64);
int hh = (int)(fr.top + m_renderer->GetDisplayRect().height());
if(hh <= m_renderer->GetDeviceRect().height() / 2)
{ {
hh *= 2; hh *= 2;
} }
@ -412,7 +449,7 @@ public:
const GIFRegTEX0& TEX0 = m_renderer->m_context->TEX0; const GIFRegTEX0& TEX0 = m_renderer->m_context->TEX0;
const GIFRegCLAMP& CLAMP = m_renderer->m_context->CLAMP; const GIFRegCLAMP& CLAMP = m_renderer->m_context->CLAMP;
const DWORD* clut = m_renderer->m_mem.m_clut; const uint32* clut = m_renderer->m_mem.m_clut;
const int pal = GSLocalMemory::m_psm[TEX0.PSM].pal; const int pal = GSLocalMemory::m_psm[TEX0.PSM].pal;
if(pal > 0) if(pal > 0)
@ -480,7 +517,7 @@ public:
{ {
if(TEX0.PSM == t->m_TEX0.PSM && TEX0.TBW == t->m_TEX0.TBW if(TEX0.PSM == t->m_TEX0.PSM && TEX0.TBW == t->m_TEX0.TBW
&& TEX0.TW == t->m_TEX0.TW && TEX0.TH == t->m_TEX0.TH && TEX0.TW == t->m_TEX0.TW && TEX0.TH == t->m_TEX0.TH
&& (m_renderer->m_psrr || (CLAMP.WMS != 3 && t->m_CLAMP.WMS != 3 && CLAMP.WMT != 3 && t->m_CLAMP.WMT != 3 || CLAMP.i64 == t->m_CLAMP.i64)) && (m_renderer->m_psrr || (CLAMP.WMS != 3 && t->m_CLAMP.WMS != 3 && CLAMP.WMT != 3 && t->m_CLAMP.WMT != 3 || CLAMP.u64 == t->m_CLAMP.u64))
&& (pal == 0 || TEX0.CPSM == t->m_TEX0.CPSM && GSVector4i::compare(t->m_clut, clut, pal * sizeof(clut[0])))) && (pal == 0 || TEX0.CPSM == t->m_TEX0.CPSM && GSVector4i::compare(t->m_clut, clut, pal * sizeof(clut[0]))))
{ {
m_tex.splice(m_tex.begin(), m_tex, i); m_tex.splice(m_tex.begin(), m_tex, i);
@ -563,14 +600,14 @@ public:
if(t->m_initpalette) if(t->m_initpalette)
{ {
memcpy(t->m_clut, clut, size); memcpy(t->m_clut, clut, size);
t->m_palette.Update(CRect(0, 0, pal, 1), t->m_clut, size); t->m_palette.Update(GSVector4i(0, 0, pal, 1), t->m_clut, size);
t->m_initpalette = false; t->m_initpalette = false;
} }
else else
{ {
if(GSVector4i::update(t->m_clut, clut, size)) if(GSVector4i::update(t->m_clut, clut, size))
{ {
t->m_palette.Update(CRect(0, 0, pal, 1), t->m_clut, size); t->m_palette.Update(GSVector4i(0, 0, pal, 1), t->m_clut, size);
} }
} }
} }
@ -603,7 +640,7 @@ public:
} }
} }
void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, const CRect& r) void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& r)
{ {
bool found = false; bool found = false;
@ -617,7 +654,7 @@ public:
{ {
if(BITBLTBUF.DBW == t->m_TEX0.TBW && !t->m_rendered) if(BITBLTBUF.DBW == t->m_TEX0.TBW && !t->m_rendered)
{ {
t->m_dirty.push_back(GSDirtyRect(BITBLTBUF.DPSM, r)); t->m_dirty.push_back(GSDirtyRect(r, BITBLTBUF.DPSM));
found = true; found = true;
} }
@ -636,16 +673,16 @@ public:
if(rowsize > 0 && offset % rowsize == 0) if(rowsize > 0 && offset % rowsize == 0)
{ {
int y = m_renderer->m_mem.m_psm[BITBLTBUF.DPSM].pgs.cy * offset / rowsize; int y = m_renderer->m_mem.m_psm[BITBLTBUF.DPSM].pgs.y * offset / rowsize;
CRect r2(r.left, r.top + y, r.right, r.bottom + y); GSVector4i r2(r.left, r.top + y, r.right, r.bottom + y);
int w = 1 << t->m_TEX0.TW; int w = 1 << t->m_TEX0.TW;
int h = 1 << t->m_TEX0.TH; int h = 1 << t->m_TEX0.TH;
if(r2.bottom > 0 && r2.top < h && r2.right > 0 && r2.left < w) if(r2.bottom > 0 && r2.top < h && r2.right > 0 && r2.left < w)
{ {
t->m_dirty.push_back(GSDirtyRect(BITBLTBUF.DPSM, r2)); t->m_dirty.push_back(GSDirtyRect(r2, BITBLTBUF.DPSM));
} }
} }
} }
@ -662,7 +699,7 @@ public:
{ {
if(!found && GSUtil::HasCompatibleBits(BITBLTBUF.DPSM, rt->m_TEX0.PSM)) if(!found && GSUtil::HasCompatibleBits(BITBLTBUF.DPSM, rt->m_TEX0.PSM))
{ {
rt->m_dirty.push_back(GSDirtyRect(BITBLTBUF.DPSM, r)); rt->m_dirty.push_back(GSDirtyRect(r, BITBLTBUF.DPSM));
rt->m_TEX0.TBW = BITBLTBUF.DBW; rt->m_TEX0.TBW = BITBLTBUF.DBW;
} }
else else
@ -675,17 +712,17 @@ public:
if(GSUtil::HasSharedBits(BITBLTBUF.DPSM, rt->m_TEX0.PSM) && BITBLTBUF.DBP < rt->m_TEX0.TBP0) if(GSUtil::HasSharedBits(BITBLTBUF.DPSM, rt->m_TEX0.PSM) && BITBLTBUF.DBP < rt->m_TEX0.TBP0)
{ {
DWORD rowsize = BITBLTBUF.DBW * 8192; uint32 rowsize = BITBLTBUF.DBW * 8192;
DWORD offset = (DWORD)((rt->m_TEX0.TBP0 - BITBLTBUF.DBP) * 256); uint32 offset = (uint32)((rt->m_TEX0.TBP0 - BITBLTBUF.DBP) * 256);
if(rowsize > 0 && offset % rowsize == 0) if(rowsize > 0 && offset % rowsize == 0)
{ {
int y = m_renderer->m_mem.m_psm[BITBLTBUF.DPSM].pgs.cy * offset / rowsize; int y = m_renderer->m_mem.m_psm[BITBLTBUF.DPSM].pgs.y * offset / rowsize;
if(r.bottom > y) if(r.bottom > y)
{ {
// TODO: do not add this rect above too // TODO: do not add this rect above too
rt->m_dirty.push_back(GSDirtyRect(BITBLTBUF.DPSM, CRect(r.left, r.top - y, r.right, r.bottom - y))); rt->m_dirty.push_back(GSDirtyRect(GSVector4i(r.left, r.top - y, r.right, r.bottom - y), BITBLTBUF.DPSM));
rt->m_TEX0.TBW = BITBLTBUF.DBW; rt->m_TEX0.TBW = BITBLTBUF.DBW;
continue; continue;
} }
@ -705,7 +742,7 @@ public:
{ {
if(!found && GSUtil::HasCompatibleBits(BITBLTBUF.DPSM, ds->m_TEX0.PSM)) if(!found && GSUtil::HasCompatibleBits(BITBLTBUF.DPSM, ds->m_TEX0.PSM))
{ {
ds->m_dirty.push_back(GSDirtyRect(BITBLTBUF.DPSM, r)); ds->m_dirty.push_back(GSDirtyRect(r, BITBLTBUF.DPSM));
ds->m_TEX0.TBW = BITBLTBUF.DBW; ds->m_TEX0.TBW = BITBLTBUF.DBW;
} }
else else
@ -718,17 +755,17 @@ public:
if(GSUtil::HasSharedBits(BITBLTBUF.DPSM, ds->m_TEX0.PSM) && BITBLTBUF.DBP < ds->m_TEX0.TBP0) if(GSUtil::HasSharedBits(BITBLTBUF.DPSM, ds->m_TEX0.PSM) && BITBLTBUF.DBP < ds->m_TEX0.TBP0)
{ {
DWORD rowsize = BITBLTBUF.DBW * 8192; uint32 rowsize = BITBLTBUF.DBW * 8192;
DWORD offset = (DWORD)((ds->m_TEX0.TBP0 - BITBLTBUF.DBP) * 256); uint32 offset = (uint32)((ds->m_TEX0.TBP0 - BITBLTBUF.DBP) * 256);
if(rowsize > 0 && offset % rowsize == 0) if(rowsize > 0 && offset % rowsize == 0)
{ {
int y = m_renderer->m_mem.m_psm[BITBLTBUF.DPSM].pgs.cy * offset / rowsize; int y = m_renderer->m_mem.m_psm[BITBLTBUF.DPSM].pgs.y * offset / rowsize;
if(r.bottom > y) if(r.bottom > y)
{ {
// TODO: do not add this rect above too // TODO: do not add this rect above too
ds->m_dirty.push_back(GSDirtyRect(BITBLTBUF.DPSM, CRect(r.left, r.top - y, r.right, r.bottom - y))); ds->m_dirty.push_back(GSDirtyRect(GSVector4i(r.left, r.top - y, r.right, r.bottom - y), BITBLTBUF.DPSM));
ds->m_TEX0.TBW = BITBLTBUF.DBW; ds->m_TEX0.TBW = BITBLTBUF.DBW;
continue; continue;
} }
@ -738,7 +775,7 @@ public:
} }
} }
void InvalidateLocalMem(const GIFRegBITBLTBUF& BITBLTBUF, const CRect& r) void InvalidateLocalMem(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& r)
{ {
for(list<GSRenderTarget*>::iterator i = m_rt.begin(); i != m_rt.end(); ) for(list<GSRenderTarget*>::iterator i = m_rt.begin(); i != m_rt.end(); )
{ {
@ -757,7 +794,7 @@ public:
{ {
// ffx-2 riku changing to her default (shoots some reflecting glass at the end), 16-bit rt read as 32-bit // ffx-2 riku changing to her default (shoots some reflecting glass at the end), 16-bit rt read as 32-bit
rt->Read(CRect(r.left, r.top, r.right, r.top + (r.bottom - r.top) * 2)); rt->Read(GSVector4i(r.left, r.top, r.right, r.top + (r.bottom - r.top) * 2));
return; return;
} }
else else
@ -784,12 +821,12 @@ public:
{ {
// ffx2 pause screen background // ffx2 pause screen background
DWORD rowsize = BITBLTBUF.SBW * 8192; uint32 rowsize = BITBLTBUF.SBW * 8192;
DWORD offset = (DWORD)((BITBLTBUF.SBP - rt->m_TEX0.TBP0) * 256); uint32 offset = (uint32)((BITBLTBUF.SBP - rt->m_TEX0.TBP0) * 256);
if(rowsize > 0 && offset % rowsize == 0) if(rowsize > 0 && offset % rowsize == 0)
{ {
int y = m_renderer->m_mem.m_psm[BITBLTBUF.SPSM].pgs.cy * offset / rowsize; int y = m_renderer->m_mem.m_psm[BITBLTBUF.SPSM].pgs.y * offset / rowsize;
if(y < ymin && y < 512) if(y < ymin && y < 512)
{ {
@ -802,7 +839,7 @@ public:
if(rt2) if(rt2)
{ {
rt2->Read(CRect(r.left, r.top + ymin, r.right, r.bottom + ymin)); rt2->Read(GSVector4i(r.left, r.top + ymin, r.right, r.bottom + ymin));
} }
// TODO: ds // TODO: ds

77
plugins/GSdx/GSTextureCache10.cpp
View File

@ -37,16 +37,14 @@ void GSTextureCache10::GSRenderTargetHW10::Update()
// FIXME: the union of the rects may also update wrong parts of the render target (but a lot faster :) // FIXME: the union of the rects may also update wrong parts of the render target (but a lot faster :)
CRect r = m_dirty.GetDirtyRect(m_TEX0, m_texture.GetSize()); GSVector4i r = m_dirty.GetDirtyRectAndClear(m_TEX0, m_texture.GetSize());
m_dirty.clear(); if(r.rempty()) return;
if(r.IsRectEmpty()) return; int w = r.width();
int h = r.height();
int w = r.Width(); static uint8* buff = (uint8*)_aligned_malloc(1024 * 1024 * 4, 16);
int h = r.Height();
static BYTE* buff = (BYTE*)_aligned_malloc(1024 * 1024 * 4, 16);
static int pitch = 1024 * 4; static int pitch = 1024 * 4;
GIFRegTEXA TEXA; GIFRegTEXA TEXA;
@ -69,7 +67,7 @@ void GSTextureCache10::GSRenderTargetHW10::Update()
if(!m_renderer->m_dev.CreateTexture(texture, w, h)) if(!m_renderer->m_dev.CreateTexture(texture, w, h))
return; return;
texture.Update(CRect(0, 0, w, h), buff, pitch); texture.Update(GSVector4i(0, 0, w, h), buff, pitch);
GSVector4 dr( GSVector4 dr(
m_texture.m_scale.x * r.left, m_texture.m_scale.x * r.left,
@ -82,7 +80,7 @@ void GSTextureCache10::GSRenderTargetHW10::Update()
m_renderer->m_dev.Recycle(texture); m_renderer->m_dev.Recycle(texture);
} }
void GSTextureCache10::GSRenderTargetHW10::Read(CRect r) void GSTextureCache10::GSRenderTargetHW10::Read(const GSVector4i& r)
{ {
if(m_TEX0.PSM != PSM_PSMCT32 if(m_TEX0.PSM != PSM_PSMCT32
&& m_TEX0.PSM != PSM_PSMCT24 && m_TEX0.PSM != PSM_PSMCT24
@ -102,8 +100,8 @@ void GSTextureCache10::GSRenderTargetHW10::Read(CRect r)
// m_renderer->m_perfmon.Put(GSPerfMon::ReadRT, 1); // m_renderer->m_perfmon.Put(GSPerfMon::ReadRT, 1);
int w = r.Width(); int w = r.width();
int h = r.Height(); int h = r.height();
GSVector4 src; GSVector4 src;
@ -119,15 +117,15 @@ void GSTextureCache10::GSRenderTargetHW10::Read(CRect r)
if(!m_renderer->m_dev.CopyOffscreen(m_texture, src, offscreen, w, h, format)) if(!m_renderer->m_dev.CopyOffscreen(m_texture, src, offscreen, w, h, format))
return; return;
BYTE* bits; uint8* bits;
int pitch; int pitch;
if(offscreen.Map(&bits, pitch)) if(offscreen.Map(&bits, pitch))
{ {
// TODO: block level write // TODO: block level write
DWORD bp = m_TEX0.TBP0; uint32 bp = m_TEX0.TBP0;
DWORD bw = m_TEX0.TBW; uint32 bw = m_TEX0.TBW;
GSLocalMemory::pixelAddress pa = GSLocalMemory::m_psm[m_TEX0.PSM].pa; GSLocalMemory::pixelAddress pa = GSLocalMemory::m_psm[m_TEX0.PSM].pa;
@ -135,12 +133,12 @@ void GSTextureCache10::GSRenderTargetHW10::Read(CRect r)
{ {
for(int y = r.top; y < r.bottom; y++, bits += pitch) for(int y = r.top; y < r.bottom; y++, bits += pitch)
{ {
DWORD addr = pa(0, y, bp, bw); uint32 addr = pa(0, y, bp, bw);
int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7]; int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7];
for(int x = r.left, i = 0; x < r.right; x++, i++) for(int x = r.left, i = 0; x < r.right; x++, i++)
{ {
m_renderer->m_mem.WritePixel32(addr + offset[x], ((DWORD*)bits)[i]); m_renderer->m_mem.WritePixel32(addr + offset[x], ((uint32*)bits)[i]);
} }
} }
} }
@ -148,12 +146,12 @@ void GSTextureCache10::GSRenderTargetHW10::Read(CRect r)
{ {
for(int y = r.top; y < r.bottom; y++, bits += pitch) for(int y = r.top; y < r.bottom; y++, bits += pitch)
{ {
DWORD addr = pa(0, y, bp, bw); uint32 addr = pa(0, y, bp, bw);
int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7]; int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7];
for(int x = r.left, i = 0; x < r.right; x++, i++) for(int x = r.left, i = 0; x < r.right; x++, i++)
{ {
m_renderer->m_mem.WritePixel24(addr + offset[x], ((DWORD*)bits)[i]); m_renderer->m_mem.WritePixel24(addr + offset[x], ((uint32*)bits)[i]);
} }
} }
} }
@ -161,12 +159,12 @@ void GSTextureCache10::GSRenderTargetHW10::Read(CRect r)
{ {
for(int y = r.top; y < r.bottom; y++, bits += pitch) for(int y = r.top; y < r.bottom; y++, bits += pitch)
{ {
DWORD addr = pa(0, y, bp, bw); uint32 addr = pa(0, y, bp, bw);
int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7]; int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7];
for(int x = r.left, i = 0; x < r.right; x++, i++) for(int x = r.left, i = 0; x < r.right; x++, i++)
{ {
m_renderer->m_mem.WritePixel16(addr + offset[x], ((WORD*)bits)[i]); m_renderer->m_mem.WritePixel16(addr + offset[x], ((uint16*)bits)[i]);
} }
} }
} }
@ -199,7 +197,7 @@ bool GSTextureCache10::GSTextureHW10::Create()
m_TEX0 = m_renderer->m_context->TEX0; m_TEX0 = m_renderer->m_context->TEX0;
m_CLAMP = m_renderer->m_context->CLAMP; m_CLAMP = m_renderer->m_context->CLAMP;
DWORD psm = m_TEX0.PSM; uint32 psm = m_TEX0.PSM;
switch(psm) switch(psm)
{ {
@ -413,40 +411,3 @@ bool GSTextureCache10::GSTextureHW10::Create(GSDepthStencil* ds)
return false; return false;
} }
void GSTextureCache10::GSTextureHW10::Update()
{
__super::Update();
if(m_rendered)
{
return;
}
CRect r;
if(!GetDirtyRect(r))
{
return;
}
m_valid |= r;
//TRACE(_T("GSTexture::Update %d,%d - %d,%d (%08x)\n"), r.left, r.top, r.right, r.bottom, m_TEX0.TBP0);
static BYTE* bits = (BYTE*)::_aligned_malloc(1024 * 1024 * 4, 16);
int pitch = 1024 * 4;
if(m_renderer->m_psrr)
{
m_renderer->m_mem.ReadTextureNPNC(r, bits, pitch, m_renderer->m_context->TEX0, m_renderer->m_env.TEXA, m_renderer->m_context->CLAMP);
}
else
{
m_renderer->m_mem.ReadTextureNP(r, bits, pitch, m_renderer->m_context->TEX0, m_renderer->m_env.TEXA, m_renderer->m_context->CLAMP);
}
m_texture.Update(r, bits, pitch);
m_renderer->m_perfmon.Put(GSPerfMon::Unswizzle, r.Width() * r.Height() * m_bpp >> 3);
}

3
plugins/GSdx/GSTextureCache10.h
View File

@ -34,7 +34,7 @@ class GSTextureCache10 : public GSTextureCache<GSDevice10>
explicit GSRenderTargetHW10(GSRenderer<GSDevice10>* renderer) : GSRenderTarget(renderer) {} explicit GSRenderTargetHW10(GSRenderer<GSDevice10>* renderer) : GSRenderTarget(renderer) {}
void Update(); void Update();
void Read(CRect r); void Read(const GSVector4i& r);
}; };
class GSDepthStencilHW10 : public GSDepthStencil class GSDepthStencilHW10 : public GSDepthStencil
@ -53,7 +53,6 @@ class GSTextureCache10 : public GSTextureCache<GSDevice10>
bool Create(); bool Create();
bool Create(GSRenderTarget* rt); bool Create(GSRenderTarget* rt);
bool Create(GSDepthStencil* ds); bool Create(GSDepthStencil* ds);
void Update();
}; };
protected: protected:

78
plugins/GSdx/GSTextureCache9.cpp
View File

@ -37,21 +37,19 @@ void GSTextureCache9::GSRenderTarget9::Update()
// FIXME: the union of the rects may also update wrong parts of the render target (but a lot faster :) // FIXME: the union of the rects may also update wrong parts of the render target (but a lot faster :)
CRect r = m_dirty.GetDirtyRect(m_TEX0, m_texture.GetSize()); GSVector4i r = m_dirty.GetDirtyRectAndClear(m_TEX0, m_texture.GetSize());
m_dirty.clear(); if(r.rempty()) return;
if(r.IsRectEmpty()) return; int w = r.width();
int h = r.height();
int w = r.Width();
int h = r.Height();
Texture texture; Texture texture;
if(!m_renderer->m_dev.CreateTexture(texture, w, h)) if(!m_renderer->m_dev.CreateTexture(texture, w, h))
return; return;
BYTE* bits; uint8* bits;
int pitch; int pitch;
if(texture.Map(&bits, pitch)) if(texture.Map(&bits, pitch))
@ -85,7 +83,7 @@ void GSTextureCache9::GSRenderTarget9::Update()
m_renderer->m_dev.Recycle(texture); m_renderer->m_dev.Recycle(texture);
} }
void GSTextureCache9::GSRenderTarget9::Read(CRect r) void GSTextureCache9::GSRenderTarget9::Read(const GSVector4i& r)
{ {
if(m_TEX0.PSM != PSM_PSMCT32 if(m_TEX0.PSM != PSM_PSMCT32
&& m_TEX0.PSM != PSM_PSMCT24 && m_TEX0.PSM != PSM_PSMCT24
@ -105,8 +103,8 @@ void GSTextureCache9::GSRenderTarget9::Read(CRect r)
// m_renderer->m_perfmon.Put(GSPerfMon::ReadRT, 1); // m_renderer->m_perfmon.Put(GSPerfMon::ReadRT, 1);
int w = r.Width(); int w = r.width();
int h = r.Height(); int h = r.height();
GSVector4 src; GSVector4 src;
@ -120,15 +118,15 @@ void GSTextureCache9::GSRenderTarget9::Read(CRect r)
if(!m_renderer->m_dev.CopyOffscreen(m_texture, src, offscreen, w, h)) if(!m_renderer->m_dev.CopyOffscreen(m_texture, src, offscreen, w, h))
return; return;
BYTE* bits; uint8* bits;
int pitch; int pitch;
if(offscreen.Map(&bits, pitch)) if(offscreen.Map(&bits, pitch))
{ {
// TODO: block level write // TODO: block level write
DWORD bp = m_TEX0.TBP0; uint32 bp = m_TEX0.TBP0;
DWORD bw = m_TEX0.TBW; uint32 bw = m_TEX0.TBW;
GSLocalMemory::pixelAddress pa = GSLocalMemory::m_psm[m_TEX0.PSM].pa; GSLocalMemory::pixelAddress pa = GSLocalMemory::m_psm[m_TEX0.PSM].pa;
@ -136,12 +134,12 @@ void GSTextureCache9::GSRenderTarget9::Read(CRect r)
{ {
for(int y = r.top; y < r.bottom; y++, bits += pitch) for(int y = r.top; y < r.bottom; y++, bits += pitch)
{ {
DWORD addr = pa(0, y, bp, bw); uint32 addr = pa(0, y, bp, bw);
int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7]; int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7];
for(int x = r.left, i = 0; x < r.right; x++, i++) for(int x = r.left, i = 0; x < r.right; x++, i++)
{ {
m_renderer->m_mem.WritePixel32(addr + offset[x], ((DWORD*)bits)[i]); m_renderer->m_mem.WritePixel32(addr + offset[x], ((uint32*)bits)[i]);
} }
} }
} }
@ -149,12 +147,12 @@ void GSTextureCache9::GSRenderTarget9::Read(CRect r)
{ {
for(int y = r.top; y < r.bottom; y++, bits += pitch) for(int y = r.top; y < r.bottom; y++, bits += pitch)
{ {
DWORD addr = pa(0, y, bp, bw); uint32 addr = pa(0, y, bp, bw);
int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7]; int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7];
for(int x = r.left, i = 0; x < r.right; x++, i++) for(int x = r.left, i = 0; x < r.right; x++, i++)
{ {
m_renderer->m_mem.WritePixel24(addr + offset[x], ((DWORD*)bits)[i]); m_renderer->m_mem.WritePixel24(addr + offset[x], ((uint32*)bits)[i]);
} }
} }
} }
@ -162,12 +160,12 @@ void GSTextureCache9::GSRenderTarget9::Read(CRect r)
{ {
for(int y = r.top; y < r.bottom; y++, bits += pitch) for(int y = r.top; y < r.bottom; y++, bits += pitch)
{ {
DWORD addr = pa(0, y, bp, bw); uint32 addr = pa(0, y, bp, bw);
int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7]; int* offset = GSLocalMemory::m_psm[m_TEX0.PSM].rowOffset[y & 7];
for(int x = r.left, i = 0; x < r.right; x++, i++) for(int x = r.left, i = 0; x < r.right; x++, i++)
{ {
m_renderer->m_mem.WriteFrame16(addr + offset[x], ((DWORD*)bits)[i]); m_renderer->m_mem.WriteFrame16(addr + offset[x], ((uint32*)bits)[i]);
} }
} }
} }
@ -200,7 +198,7 @@ bool GSTextureCache9::GSTexture9::Create()
m_TEX0 = m_renderer->m_context->TEX0; m_TEX0 = m_renderer->m_context->TEX0;
m_CLAMP = m_renderer->m_context->CLAMP; m_CLAMP = m_renderer->m_context->CLAMP;
DWORD psm = m_TEX0.PSM; uint32 psm = m_TEX0.PSM;
switch(psm) switch(psm)
{ {
@ -358,7 +356,7 @@ bool GSTextureCache9::GSTexture9::Create(GSRenderTarget* rt)
if(src.x == dst.x && src.y == dst.y && src.z == dst.z && src.w == dst.w) if(src.x == dst.x && src.y == dst.y && src.z == dst.z && src.w == dst.w)
{ {
CRect r(0, 0, w, h); GSVector4i r(0, 0, w, h);
m_renderer->m_dev->StretchRect(*st, r, *dt, r, D3DTEXF_POINT); m_renderer->m_dev->StretchRect(*st, r, *dt, r, D3DTEXF_POINT);
} }
@ -413,41 +411,3 @@ bool GSTextureCache9::GSTexture9::Create(GSDepthStencil* ds)
return false; return false;
} }
void GSTextureCache9::GSTexture9::Update()
{
__super::Update();
if(m_rendered)
{
return;
}
CRect r;
if(!GetDirtyRect(r))
{
return;
}
m_valid |= r;
BYTE* bits;
int pitch;
if(m_texture.Map(&bits, pitch, &r))
{
if(m_renderer->m_psrr)
{
m_renderer->m_mem.ReadTextureNPNC(r, bits, pitch, m_renderer->m_context->TEX0, m_renderer->m_env.TEXA, m_renderer->m_context->CLAMP);
}
else
{
m_renderer->m_mem.ReadTextureNP(r, bits, pitch, m_renderer->m_context->TEX0, m_renderer->m_env.TEXA, m_renderer->m_context->CLAMP);
}
m_texture.Unmap();
}
m_renderer->m_perfmon.Put(GSPerfMon::Unswizzle, r.Width() * r.Height() * m_bpp >> 3);
}

3
plugins/GSdx/GSTextureCache9.h
View File

@ -34,7 +34,7 @@ class GSTextureCache9 : public GSTextureCache<GSDevice9>
explicit GSRenderTarget9(GSRenderer<GSDevice9>* renderer) : GSRenderTarget(renderer) {} explicit GSRenderTarget9(GSRenderer<GSDevice9>* renderer) : GSRenderTarget(renderer) {}
void Update(); void Update();
void Read(CRect r); void Read(const GSVector4i& r);
}; };
class GSDepthStencil9 : public GSDepthStencil class GSDepthStencil9 : public GSDepthStencil
@ -53,7 +53,6 @@ class GSTextureCache9 : public GSTextureCache<GSDevice9>
bool Create(); bool Create();
bool Create(GSRenderTarget* rt); bool Create(GSRenderTarget* rt);
bool Create(GSDepthStencil* ds); bool Create(GSDepthStencil* ds);
void Update();
}; };
protected: protected:

114
plugins/GSdx/GSTextureCacheSW.cpp
View File

@ -32,7 +32,7 @@ GSTextureCacheSW::~GSTextureCacheSW()
RemoveAll(); RemoveAll();
} }
const GSTextureCacheSW::GSTexture* GSTextureCacheSW::Lookup(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const CRect* r) const GSTextureCacheSW::GSTexture* GSTextureCacheSW::Lookup(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const GSVector4i* r)
{ {
GSLocalMemory& mem = m_state->m_mem; GSLocalMemory& mem = m_state->m_mem;
@ -47,12 +47,12 @@ const GSTextureCacheSW::GSTexture* GSTextureCacheSW::Lookup(const GIFRegTEX0& TE
GSTexture* t2 = (*i).first; GSTexture* t2 = (*i).first;
// if(t2->m_TEX0.TBP0 != TEX0.TBP0 || t2->m_TEX0.TBW != TEX0.TBW || t2->m_TEX0.PSM != TEX0.PSM || t2->m_TEX0.TW != TEX0.TW || t2->m_TEX0.TH != TEX0.TH) // if(t2->m_TEX0.TBP0 != TEX0.TBP0 || t2->m_TEX0.TBW != TEX0.TBW || t2->m_TEX0.PSM != TEX0.PSM || t2->m_TEX0.TW != TEX0.TW || t2->m_TEX0.TH != TEX0.TH)
if(((t2->m_TEX0.ai32[0] ^ TEX0.ai32[0]) | ((t2->m_TEX0.ai32[1] ^ TEX0.ai32[1]) & 3)) != 0) if(((t2->m_TEX0.u32[0] ^ TEX0.u32[0]) | ((t2->m_TEX0.u32[1] ^ TEX0.u32[1]) & 3)) != 0)
{ {
continue; continue;
} }
if((psm.trbpp == 16 || psm.trbpp == 24) && (t2->m_TEX0.TCC != TEX0.TCC || TEX0.TCC && !(t2->m_TEXA == (GSVector4i)TEXA).alltrue())) if((psm.trbpp == 16 || psm.trbpp == 24) && (t2->m_TEX0.TCC != TEX0.TCC || TEX0.TCC && !((GSVector4i)TEXA).eq(t2->m_TEXA)))
{ {
continue; continue;
} }
@ -73,18 +73,18 @@ const GSTextureCacheSW::GSTexture* GSTextureCacheSW::Lookup(const GIFRegTEX0& TE
int tw = 1 << TEX0.TW; int tw = 1 << TEX0.TW;
int th = 1 << TEX0.TH; int th = 1 << TEX0.TH;
DWORD bp = TEX0.TBP0; uint32 bp = TEX0.TBP0;
DWORD bw = TEX0.TBW; uint32 bw = TEX0.TBW;
CSize s = (bp & 31) == 0 ? psm.pgs : psm.bs; GSVector2i s = (bp & 31) == 0 ? psm.pgs : psm.bs;
for(int y = 0; y < th; y += s.cy) for(int y = 0; y < th; y += s.y)
{ {
DWORD base = psm.bn(0, y, bp, bw); uint32 base = psm.bn(0, y, bp, bw);
for(int x = 0; x < tw; x += s.cx) for(int x = 0; x < tw; x += s.x)
{ {
DWORD page = (base + psm.blockOffset[x >> 3]) >> 5; uint32 page = (base + psm.blockOffset[x >> 3]) >> 5;
if(page >= MAX_PAGES) if(page >= MAX_PAGES)
{ {
@ -152,29 +152,29 @@ void GSTextureCacheSW::IncAge()
} }
} }
void GSTextureCacheSW::InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, const CRect& rect) void GSTextureCacheSW::InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& rect)
{ {
const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[BITBLTBUF.DPSM]; const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[BITBLTBUF.DPSM];
DWORD bp = BITBLTBUF.DBP; uint32 bp = BITBLTBUF.DBP;
DWORD bw = BITBLTBUF.DBW; uint32 bw = BITBLTBUF.DBW;
CSize s = (bp & 31) == 0 ? psm.pgs : psm.bs; GSVector2i s = (bp & 31) == 0 ? psm.pgs : psm.bs;
CRect r; GSVector4i r;
r.left = rect.left & ~(s.cx - 1); r.left = rect.left & ~(s.x - 1);
r.top = rect.top & ~(s.cy - 1); r.top = rect.top & ~(s.y - 1);
r.right = (rect.right + (s.cx - 1)) & ~(s.cx - 1); r.right = (rect.right + (s.x - 1)) & ~(s.x - 1);
r.bottom = (rect.bottom + (s.cy - 1)) & ~(s.cy - 1); r.bottom = (rect.bottom + (s.y - 1)) & ~(s.y - 1);
for(int y = r.top; y < r.bottom; y += s.cy) for(int y = r.top; y < r.bottom; y += s.y)
{ {
DWORD base = psm.bn(0, y, bp, bw); uint32 base = psm.bn(0, y, bp, bw);
for(int x = r.left; x < r.right; x += s.cx) for(int x = r.left; x < r.right; x += s.x)
{ {
DWORD page = (base + psm.blockOffset[x >> 3]) >> 5; uint32 page = (base + psm.blockOffset[x >> 3]) >> 5;
if(page >= MAX_PAGES) if(page >= MAX_PAGES)
{ {
@ -215,7 +215,7 @@ GSTextureCacheSW::GSTexture::~GSTexture()
} }
} }
bool GSTextureCacheSW::GSTexture::Update(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const CRect* rect) bool GSTextureCacheSW::GSTexture::Update(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const GSVector4i* rect)
{ {
if(m_complete) if(m_complete)
{ {
@ -229,17 +229,17 @@ bool GSTextureCacheSW::GSTexture::Update(const GIFRegTEX0& TEX0, const GIFRegTEX
const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[TEX0.PSM]; const GSLocalMemory::psm_t& psm = GSLocalMemory::m_psm[TEX0.PSM];
DWORD bp = TEX0.TBP0; uint32 bp = TEX0.TBP0;
DWORD bw = TEX0.TBW; uint32 bw = TEX0.TBW;
CSize s = psm.bs; GSVector2i s = psm.bs;
int tw = max(1 << TEX0.TW, s.cx); int tw = max(1 << TEX0.TW, s.x);
int th = max(1 << TEX0.TH, s.cy); int th = max(1 << TEX0.TH, s.y);
if(m_buff == NULL) if(m_buff == NULL)
{ {
m_buff = _aligned_malloc(tw * th * sizeof(DWORD), 16); m_buff = _aligned_malloc(tw * th * sizeof(uint32), 16);
if(m_buff == NULL) if(m_buff == NULL)
{ {
@ -249,14 +249,14 @@ bool GSTextureCacheSW::GSTexture::Update(const GIFRegTEX0& TEX0, const GIFRegTEX
m_tw = max(psm.pal > 0 ? 5 : 3, TEX0.TW); // makes one row 32 bytes at least, matches the smallest block size that is allocated above for m_buff m_tw = max(psm.pal > 0 ? 5 : 3, TEX0.TW); // makes one row 32 bytes at least, matches the smallest block size that is allocated above for m_buff
} }
CRect r(0, 0, tw, th); GSVector4i r(0, 0, tw, th);
if(rect) if(rect)
{ {
r.left = rect->left & ~(s.cx - 1); r.left = rect->left & ~(s.x - 1);
r.top = rect->top & ~(s.cy - 1); r.top = rect->top & ~(s.y - 1);
r.right = (rect->right + (s.cx - 1)) & ~(s.cx - 1); r.right = (rect->right + (s.x - 1)) & ~(s.x - 1);
r.bottom = (rect->bottom + (s.cy - 1)) & ~(s.cy - 1); r.bottom = (rect->bottom + (s.y - 1)) & ~(s.y - 1);
} }
if(r.left == 0 && r.top == 0 && r.right == tw && r.bottom == th) if(r.left == 0 && r.top == 0 && r.right == tw && r.bottom == th)
@ -268,26 +268,26 @@ bool GSTextureCacheSW::GSTexture::Update(const GIFRegTEX0& TEX0, const GIFRegTEX
int bytes = psm.pal > 0 ? 1 : 4; int bytes = psm.pal > 0 ? 1 : 4;
DWORD pitch = (1 << m_tw) * bytes; uint32 pitch = (1 << m_tw) * bytes;
BYTE* dst = (BYTE*)m_buff + pitch * r.top; uint8* dst = (uint8*)m_buff + pitch * r.top;
DWORD blocks = 0; uint32 blocks = 0;
if(tw <= (bw << 6)) if(tw <= (bw << 6))
{ {
for(int y = r.top, o = pitch * s.cy; y < r.bottom; y += s.cy, dst += o) for(int y = r.top, o = pitch * s.y; y < r.bottom; y += s.y, dst += o)
{ {
DWORD base = psm.bn(0, y, bp, bw); uint32 base = psm.bn(0, y, bp, bw);
for(int x = r.left; x < r.right; x += s.cx) for(int x = r.left; x < r.right; x += s.x)
{ {
DWORD block = base + psm.blockOffset[x >> 3]; uint32 block = base + psm.blockOffset[x >> 3];
if(block < MAX_BLOCKS) if(block < MAX_BLOCKS)
{ {
DWORD row = block >> 5; uint32 row = block >> 5;
DWORD col = 1 << (block & 31); uint32 col = 1 << (block & 31);
if((m_valid[row] & col) == 0) if((m_valid[row] & col) == 0)
{ {
@ -308,18 +308,18 @@ bool GSTextureCacheSW::GSTexture::Update(const GIFRegTEX0& TEX0, const GIFRegTEX
// TODO: still bogus if those repeated parts aren't fetched together // TODO: still bogus if those repeated parts aren't fetched together
for(int y = r.top, o = pitch * s.cy; y < r.bottom; y += s.cy, dst += o) for(int y = r.top, o = pitch * s.y; y < r.bottom; y += s.y, dst += o)
{ {
DWORD base = psm.bn(0, y, bp, bw); uint32 base = psm.bn(0, y, bp, bw);
for(int x = r.left; x < r.right; x += s.cx) for(int x = r.left; x < r.right; x += s.x)
{ {
DWORD block = base + psm.blockOffset[x >> 3]; uint32 block = base + psm.blockOffset[x >> 3];
if(block < MAX_BLOCKS) if(block < MAX_BLOCKS)
{ {
DWORD row = block >> 5; uint32 row = block >> 5;
DWORD col = 1 << (block & 31); uint32 col = 1 << (block & 31);
if((m_valid[row] & col) == 0) if((m_valid[row] & col) == 0)
{ {
@ -331,18 +331,18 @@ bool GSTextureCacheSW::GSTexture::Update(const GIFRegTEX0& TEX0, const GIFRegTEX
} }
} }
for(int y = r.top; y < r.bottom; y += s.cy) for(int y = r.top; y < r.bottom; y += s.y)
{ {
DWORD base = psm.bn(0, y, bp, bw); uint32 base = psm.bn(0, y, bp, bw);
for(int x = r.left; x < r.right; x += s.cx) for(int x = r.left; x < r.right; x += s.x)
{ {
DWORD block = base + psm.blockOffset[x >> 3]; uint32 block = base + psm.blockOffset[x >> 3];
if(block < MAX_BLOCKS) if(block < MAX_BLOCKS)
{ {
DWORD row = block >> 5; uint32 row = block >> 5;
DWORD col = 1 << (block & 31); uint32 col = 1 << (block & 31);
m_valid[row] |= col; m_valid[row] |= col;
} }
@ -350,7 +350,7 @@ bool GSTextureCacheSW::GSTexture::Update(const GIFRegTEX0& TEX0, const GIFRegTEX
} }
} }
m_state->m_perfmon.Put(GSPerfMon::Unswizzle, s.cx * s.cy * bytes * blocks); m_state->m_perfmon.Put(GSPerfMon::Unswizzle, s.x * s.y * bytes * blocks);
return true; return true;
} }

12
plugins/GSdx/GSTextureCacheSW.h
View File

@ -36,15 +36,15 @@ public:
GIFRegTEX0 m_TEX0; GIFRegTEX0 m_TEX0;
GIFRegTEXA m_TEXA; GIFRegTEXA m_TEXA;
void* m_buff; void* m_buff;
DWORD m_tw; uint32 m_tw;
DWORD m_valid[MAX_PAGES]; // each DWORD bits map to the 32 blocks of that page uint32 m_valid[MAX_PAGES]; // each uint32 bits map to the 32 blocks of that page
DWORD m_age; uint32 m_age;
bool m_complete; bool m_complete;
explicit GSTexture(GSState* state); explicit GSTexture(GSState* state);
virtual ~GSTexture(); virtual ~GSTexture();
bool Update(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const CRect* r = NULL); bool Update(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const GSVector4i* r = NULL);
}; };
protected: protected:
@ -56,9 +56,9 @@ public:
GSTextureCacheSW(GSState* state); GSTextureCacheSW(GSState* state);
virtual ~GSTextureCacheSW(); virtual ~GSTextureCacheSW();
const GSTexture* Lookup(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const CRect* r = NULL); const GSTexture* Lookup(const GIFRegTEX0& TEX0, const GIFRegTEXA& TEXA, const GSVector4i* r = NULL);
void RemoveAll(); void RemoveAll();
void IncAge(); void IncAge();
void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, const CRect& r); void InvalidateVideoMem(const GIFRegBITBLTBUF& BITBLTBUF, const GSVector4i& r);
}; };

14
plugins/GSdx/GSTextureFX10.cpp
View File

@ -163,7 +163,7 @@ bool GSTextureFX10::SetupVS(VSSelector sel, const VSConstantBuffer* cb)
{ {
CComPtr<ID3D10VertexShader> vs; CComPtr<ID3D10VertexShader> vs;
hash_map<DWORD, CComPtr<ID3D10VertexShader> >::iterator i = m_vs.find(sel); hash_map<uint32, CComPtr<ID3D10VertexShader> >::iterator i = m_vs.find(sel);
if(i != m_vs.end()) if(i != m_vs.end())
{ {
@ -229,7 +229,7 @@ bool GSTextureFX10::SetupGS(GSSelector sel)
if(sel.prim > 0 && (sel.iip == 0 || sel.prim == 3)) // geometry shader works in every case, but not needed if(sel.prim > 0 && (sel.iip == 0 || sel.prim == 3)) // geometry shader works in every case, but not needed
{ {
hash_map<DWORD, CComPtr<ID3D10GeometryShader> >::iterator i = m_gs.find(sel); hash_map<uint32, CComPtr<ID3D10GeometryShader> >::iterator i = m_gs.find(sel);
if(i != m_gs.end()) if(i != m_gs.end())
{ {
@ -275,7 +275,7 @@ void GSTextureFX10::UpdatePS(PSSelector sel, const PSConstantBuffer* cb, PSSampl
CComPtr<ID3D10PixelShader> ps; CComPtr<ID3D10PixelShader> ps;
hash_map<DWORD, CComPtr<ID3D10PixelShader> >::iterator i = m_ps.find(sel); hash_map<uint32, CComPtr<ID3D10PixelShader> >::iterator i = m_ps.find(sel);
if(i != m_ps.end()) if(i != m_ps.end())
{ {
@ -338,7 +338,7 @@ void GSTextureFX10::UpdatePS(PSSelector sel, const PSConstantBuffer* cb, PSSampl
ssel.min = ssel.mag = 0; ssel.min = ssel.mag = 0;
} }
hash_map<DWORD, CComPtr<ID3D10SamplerState> >::iterator i = m_ps_ss.find(ssel); hash_map<uint32, CComPtr<ID3D10SamplerState> >::iterator i = m_ps_ss.find(ssel);
if(i != m_ps_ss.end()) if(i != m_ps_ss.end())
{ {
@ -378,7 +378,7 @@ void GSTextureFX10::UpdatePS(PSSelector sel, const PSConstantBuffer* cb, PSSampl
m_dev->PSSetSamplerState(ss0, ss1); m_dev->PSSetSamplerState(ss0, ss1);
} }
void GSTextureFX10::SetupRS(UINT w, UINT h, const RECT& scissor) void GSTextureFX10::SetupRS(int w, int h, const GSVector4i& scissor)
{ {
m_dev->RSSet(w, h, &scissor); m_dev->RSSet(w, h, &scissor);
} }
@ -396,7 +396,7 @@ void GSTextureFX10::UpdateOM(OMDepthStencilSelector dssel, OMBlendSelector bsel,
CComPtr<ID3D10DepthStencilState> dss; CComPtr<ID3D10DepthStencilState> dss;
hash_map<DWORD, CComPtr<ID3D10DepthStencilState> >::iterator i = m_om_dss.find(dssel); hash_map<uint32, CComPtr<ID3D10DepthStencilState> >::iterator i = m_om_dss.find(dssel);
if(i != m_om_dss.end()) if(i != m_om_dss.end())
{ {
@ -447,7 +447,7 @@ void GSTextureFX10::UpdateOM(OMDepthStencilSelector dssel, OMBlendSelector bsel,
CComPtr<ID3D10BlendState> bs; CComPtr<ID3D10BlendState> bs;
hash_map<DWORD, CComPtr<ID3D10BlendState> >::iterator j = m_om_bs.find(bsel); hash_map<uint32, CComPtr<ID3D10BlendState> >::iterator j = m_om_bs.find(bsel);
if(j != m_om_bs.end()) if(j != m_om_bs.end())
{ {

120
plugins/GSdx/GSTextureFX10.h
View File

@ -63,16 +63,16 @@ public:
{ {
struct struct
{ {
DWORD bpp:3; uint32 bpp:3;
DWORD bppz:2; uint32 bppz:2;
DWORD tme:1; uint32 tme:1;
DWORD fst:1; uint32 fst:1;
DWORD prim:3; uint32 prim:3;
}; };
DWORD dw; uint32 key;
operator DWORD() {return dw & 0x3ff;} operator uint32() {return key & 0x3ff;}
}; };
__declspec(align(16)) struct PSConstantBuffer __declspec(align(16)) struct PSConstantBuffer
@ -82,10 +82,10 @@ public:
float MAXU; float MAXU;
float MINV; float MINV;
float MAXV; float MAXV;
DWORD UMSK; uint32 UMSK;
DWORD UFIX; uint32 UFIX;
DWORD VMSK; uint32 VMSK;
DWORD VFIX; uint32 VFIX;
float TA0; float TA0;
float TA1; float TA1;
float AREF; float AREF;
@ -125,87 +125,87 @@ public:
{ {
struct struct
{ {
DWORD fst:1; uint32 fst:1;
DWORD wms:2; uint32 wms:2;
DWORD wmt:2; uint32 wmt:2;
DWORD bpp:3; uint32 bpp:3;
DWORD aem:1; uint32 aem:1;
DWORD tfx:3; uint32 tfx:3;
DWORD tcc:1; uint32 tcc:1;
DWORD ate:1; uint32 ate:1;
DWORD atst:3; uint32 atst:3;
DWORD fog:1; uint32 fog:1;
DWORD clr1:1; uint32 clr1:1;
DWORD fba:1; uint32 fba:1;
DWORD aout:1; uint32 aout:1;
}; };
DWORD dw; uint32 key;
operator DWORD() {return dw & 0x1fffff;} operator uint32() {return key & 0x1fffff;}
}; };
union GSSelector union GSSelector
{ {
struct struct
{ {
DWORD iip:1; uint32 iip:1;
DWORD prim:2; uint32 prim:2;
}; };
DWORD dw; uint32 key;
operator DWORD() {return dw & 0x7;} operator uint32() {return key & 0x7;}
}; };
union PSSamplerSelector union PSSamplerSelector
{ {
struct struct
{ {
DWORD tau:1; uint32 tau:1;
DWORD tav:1; uint32 tav:1;
DWORD min:1; uint32 min:1;
DWORD mag:1; uint32 mag:1;
}; };
DWORD dw; uint32 key;
operator DWORD() {return dw & 0xf;} operator uint32() {return key & 0xf;}
}; };
union OMDepthStencilSelector union OMDepthStencilSelector
{ {
struct struct
{ {
DWORD zte:1; uint32 zte:1;
DWORD ztst:2; uint32 ztst:2;
DWORD zwe:1; uint32 zwe:1;
DWORD date:1; uint32 date:1;
}; };
DWORD dw; uint32 key;
operator DWORD() {return dw & 0x1f;} operator uint32() {return key & 0x1f;}
}; };
union OMBlendSelector union OMBlendSelector
{ {
struct struct
{ {
DWORD abe:1; uint32 abe:1;
DWORD a:2; uint32 a:2;
DWORD b:2; uint32 b:2;
DWORD c:2; uint32 c:2;
DWORD d:2; uint32 d:2;
DWORD wr:1; uint32 wr:1;
DWORD wg:1; uint32 wg:1;
DWORD wb:1; uint32 wb:1;
DWORD wa:1; uint32 wa:1;
}; };
DWORD dw; uint32 key;
operator DWORD() {return dw & 0x1fff;} operator uint32() {return key & 0x1fff;}
}; };
#pragma pack(pop) #pragma pack(pop)
@ -213,15 +213,15 @@ public:
private: private:
GSDevice10* m_dev; GSDevice10* m_dev;
CComPtr<ID3D10InputLayout> m_il; CComPtr<ID3D10InputLayout> m_il;
hash_map<DWORD, CComPtr<ID3D10VertexShader> > m_vs; hash_map<uint32, CComPtr<ID3D10VertexShader> > m_vs;
CComPtr<ID3D10Buffer> m_vs_cb; CComPtr<ID3D10Buffer> m_vs_cb;
hash_map<DWORD, CComPtr<ID3D10GeometryShader> > m_gs; hash_map<uint32, CComPtr<ID3D10GeometryShader> > m_gs;
hash_map<DWORD, CComPtr<ID3D10PixelShader> > m_ps; hash_map<uint32, CComPtr<ID3D10PixelShader> > m_ps;
CComPtr<ID3D10Buffer> m_ps_cb; CComPtr<ID3D10Buffer> m_ps_cb;
hash_map<DWORD, CComPtr<ID3D10SamplerState> > m_ps_ss; hash_map<uint32, CComPtr<ID3D10SamplerState> > m_ps_ss;
CComPtr<ID3D10SamplerState> m_palette_ss; CComPtr<ID3D10SamplerState> m_palette_ss;
hash_map<DWORD, CComPtr<ID3D10DepthStencilState> > m_om_dss; hash_map<uint32, CComPtr<ID3D10DepthStencilState> > m_om_dss;
hash_map<DWORD, CComPtr<ID3D10BlendState> > m_om_bs; hash_map<uint32, CComPtr<ID3D10BlendState> > m_om_bs;
CComPtr<ID3D10Buffer> m_vb, m_vb_old; CComPtr<ID3D10Buffer> m_vb, m_vb_old;
int m_vb_max; int m_vb_max;
@ -241,7 +241,7 @@ public:
bool SetupGS(GSSelector sel); bool SetupGS(GSSelector sel);
bool SetupPS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSelector ssel, ID3D10ShaderResourceView* tex, ID3D10ShaderResourceView* pal); bool SetupPS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSelector ssel, ID3D10ShaderResourceView* tex, ID3D10ShaderResourceView* pal);
void UpdatePS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSelector ssel); void UpdatePS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSelector ssel);
void SetupRS(UINT w, UINT h, const RECT& scissor); void SetupRS(int w, int h, const GSVector4i& scissor);
void SetupOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, float bf, ID3D10RenderTargetView* rtv, ID3D10DepthStencilView* dsv); void SetupOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, float bf, ID3D10RenderTargetView* rtv, ID3D10DepthStencilView* dsv);
void UpdateOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, float bf); void UpdateOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, float bf);
void Draw(); void Draw();

28
plugins/GSdx/GSTextureFX9.cpp
View File

@ -46,11 +46,11 @@ bool GSTextureFX9::Create(GSDevice9* dev)
return true; return true;
} }
bool GSTextureFX9::CreateMskFix(GSTexture9& t, DWORD size, DWORD msk, DWORD fix) bool GSTextureFX9::CreateMskFix(GSTexture9& t, uint32 size, uint32 msk, uint32 fix)
{ {
DWORD hash = (size << 20) | (msk << 10) | fix; uint32 hash = (size << 20) | (msk << 10) | fix;
hash_map<DWORD, GSTexture9>::iterator i = m_mskfix.find(hash); hash_map<uint32, GSTexture9>::iterator i = m_mskfix.find(hash);
if(i != m_mskfix.end()) if(i != m_mskfix.end())
{ {
@ -63,12 +63,12 @@ bool GSTextureFX9::CreateMskFix(GSTexture9& t, DWORD size, DWORD msk, DWORD fix)
return false; return false;
} }
BYTE* bits; uint8* bits;
int pitch; int pitch;
if(t.Map(&bits, pitch)) if(t.Map(&bits, pitch))
{ {
for(DWORD i = 0; i < size; i++) for(uint32 i = 0; i < size; i++)
{ {
((float*)bits)[i] = (float)((i & msk) | fix) / size; ((float*)bits)[i] = (float)((i & msk) | fix) / size;
} }
@ -82,7 +82,7 @@ bool GSTextureFX9::CreateMskFix(GSTexture9& t, DWORD size, DWORD msk, DWORD fix)
return true; return true;
} }
bool GSTextureFX9::SetupIA(const GSVertexHW9* vertices, UINT count, D3DPRIMITIVETYPE prim) bool GSTextureFX9::SetupIA(const GSVertexHW9* vertices, int count, D3DPRIMITIVETYPE prim)
{ {
m_dev->IASetVertexBuffer(count, vertices); m_dev->IASetVertexBuffer(count, vertices);
m_dev->IASetInputLayout(m_il); m_dev->IASetInputLayout(m_il);
@ -95,7 +95,7 @@ bool GSTextureFX9::SetupVS(VSSelector sel, const VSConstantBuffer* cb)
{ {
CComPtr<IDirect3DVertexShader9> vs; CComPtr<IDirect3DVertexShader9> vs;
hash_map<DWORD, CComPtr<IDirect3DVertexShader9> >::iterator i = m_vs.find(sel); hash_map<uint32, CComPtr<IDirect3DVertexShader9> >::iterator i = m_vs.find(sel);
if(i != m_vs.end()) if(i != m_vs.end())
{ {
@ -191,7 +191,7 @@ void GSTextureFX9::UpdatePS(PSSelector sel, const PSConstantBuffer* cb, PSSample
CComPtr<IDirect3DPixelShader9> ps; CComPtr<IDirect3DPixelShader9> ps;
hash_map<DWORD, CComPtr<IDirect3DPixelShader9> >::iterator i = m_ps.find(sel); hash_map<uint32, CComPtr<IDirect3DPixelShader9> >::iterator i = m_ps.find(sel);
if(i != m_ps.end()) if(i != m_ps.end())
{ {
@ -247,7 +247,7 @@ void GSTextureFX9::UpdatePS(PSSelector sel, const PSConstantBuffer* cb, PSSample
ssel.min = ssel.mag = 0; ssel.min = ssel.mag = 0;
} }
hash_map<DWORD, Direct3DSamplerState9* >::iterator i = m_ps_ss.find(ssel); hash_map<uint32, Direct3DSamplerState9* >::iterator i = m_ps_ss.find(ssel);
if(i != m_ps_ss.end()) if(i != m_ps_ss.end())
{ {
@ -274,23 +274,23 @@ void GSTextureFX9::UpdatePS(PSSelector sel, const PSConstantBuffer* cb, PSSample
m_dev->PSSetSamplerState(ss); m_dev->PSSetSamplerState(ss);
} }
void GSTextureFX9::SetupRS(int w, int h, const RECT& scissor) void GSTextureFX9::SetupRS(int w, int h, const GSVector4i& scissor)
{ {
m_dev->RSSet(w, h, &scissor); m_dev->RSSet(w, h, &scissor);
} }
void GSTextureFX9::SetupOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, BYTE bf, IDirect3DSurface9* rt, IDirect3DSurface9* ds) void GSTextureFX9::SetupOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, uint8 bf, IDirect3DSurface9* rt, IDirect3DSurface9* ds)
{ {
UpdateOM(dssel, bsel, bf); UpdateOM(dssel, bsel, bf);
m_dev->OMSetRenderTargets(rt, ds); m_dev->OMSetRenderTargets(rt, ds);
} }
void GSTextureFX9::UpdateOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, BYTE bf) void GSTextureFX9::UpdateOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, uint8 bf)
{ {
Direct3DDepthStencilState9* dss = NULL; Direct3DDepthStencilState9* dss = NULL;
hash_map<DWORD, Direct3DDepthStencilState9*>::iterator i = m_om_dss.find(dssel); hash_map<uint32, Direct3DDepthStencilState9*>::iterator i = m_om_dss.find(dssel);
if(i != m_om_dss.end()) if(i != m_om_dss.end())
{ {
@ -335,7 +335,7 @@ void GSTextureFX9::UpdateOM(OMDepthStencilSelector dssel, OMBlendSelector bsel,
Direct3DBlendState9* bs = NULL; Direct3DBlendState9* bs = NULL;
hash_map<DWORD, Direct3DBlendState9*>::iterator j = m_om_bs.find(bsel); hash_map<uint32, Direct3DBlendState9*>::iterator j = m_om_bs.find(bsel);
if(j != m_om_bs.end()) if(j != m_om_bs.end())
{ {

118
plugins/GSdx/GSTextureFX9.h
View File

@ -40,15 +40,15 @@ public:
{ {
struct struct
{ {
DWORD bppz:2; uint32 bppz:2;
DWORD tme:1; uint32 tme:1;
DWORD fst:1; uint32 fst:1;
DWORD logz:1; uint32 logz:1;
}; };
DWORD dw; uint32 key;
operator DWORD() {return dw & 0x1f;} operator uint32() {return key & 0x1f;}
}; };
struct PSConstantBuffer struct PSConstantBuffer
@ -58,10 +58,10 @@ public:
float MAXU; float MAXU;
float MINV; float MINV;
float MAXV; float MAXV;
DWORD UMSK; uint32 UMSK;
DWORD UFIX; uint32 UFIX;
DWORD VMSK; uint32 VMSK;
DWORD VFIX; uint32 VFIX;
float TA0; float TA0;
float TA1; float TA1;
float AREF; float AREF;
@ -74,74 +74,74 @@ public:
{ {
struct struct
{ {
DWORD fst:1; uint32 fst:1;
DWORD wms:2; uint32 wms:2;
DWORD wmt:2; uint32 wmt:2;
DWORD bpp:3; uint32 bpp:3;
DWORD aem:1; uint32 aem:1;
DWORD tfx:3; uint32 tfx:3;
DWORD tcc:1; uint32 tcc:1;
DWORD ate:1; uint32 ate:1;
DWORD atst:3; uint32 atst:3;
DWORD fog:1; uint32 fog:1;
DWORD clr1:1; uint32 clr1:1;
DWORD rt:1; uint32 rt:1;
}; };
DWORD dw; uint32 key;
operator DWORD() {return dw & 0xfffff;} operator uint32() {return key & 0xfffff;}
}; };
union PSSamplerSelector union PSSamplerSelector
{ {
struct struct
{ {
DWORD tau:1; uint32 tau:1;
DWORD tav:1; uint32 tav:1;
DWORD min:1; uint32 min:1;
DWORD mag:1; uint32 mag:1;
}; };
DWORD dw; uint32 key;
operator DWORD() {return dw & 0xf;} operator uint32() {return key & 0xf;}
}; };
union OMDepthStencilSelector union OMDepthStencilSelector
{ {
struct struct
{ {
DWORD zte:1; uint32 zte:1;
DWORD ztst:2; uint32 ztst:2;
DWORD zwe:1; uint32 zwe:1;
DWORD date:1; uint32 date:1;
DWORD fba:1; uint32 fba:1;
}; };
DWORD dw; uint32 key;
operator DWORD() {return dw & 0x3f;} operator uint32() {return key & 0x3f;}
}; };
union OMBlendSelector union OMBlendSelector
{ {
struct struct
{ {
DWORD abe:1; uint32 abe:1;
DWORD a:2; uint32 a:2;
DWORD b:2; uint32 b:2;
DWORD c:2; uint32 c:2;
DWORD d:2; uint32 d:2;
DWORD wr:1; uint32 wr:1;
DWORD wg:1; uint32 wg:1;
DWORD wb:1; uint32 wb:1;
DWORD wa:1; uint32 wa:1;
}; };
DWORD dw; uint32 key;
operator DWORD() {return dw & 0x1fff;} operator uint32() {return key & 0x1fff;}
}; };
#pragma pack(pop) #pragma pack(pop)
@ -149,25 +149,25 @@ public:
private: private:
GSDevice9* m_dev; GSDevice9* m_dev;
CComPtr<IDirect3DVertexDeclaration9> m_il; CComPtr<IDirect3DVertexDeclaration9> m_il;
hash_map<DWORD, CComPtr<IDirect3DVertexShader9> > m_vs; hash_map<uint32, CComPtr<IDirect3DVertexShader9> > m_vs;
D3DXHANDLE m_vs_params; D3DXHANDLE m_vs_params;
hash_map<DWORD, CComPtr<IDirect3DPixelShader9> > m_ps; hash_map<uint32, CComPtr<IDirect3DPixelShader9> > m_ps;
hash_map<DWORD, Direct3DSamplerState9* > m_ps_ss; hash_map<uint32, Direct3DSamplerState9* > m_ps_ss;
hash_map<DWORD, Direct3DDepthStencilState9* > m_om_dss; hash_map<uint32, Direct3DDepthStencilState9* > m_om_dss;
hash_map<DWORD, Direct3DBlendState9* > m_om_bs; hash_map<uint32, Direct3DBlendState9* > m_om_bs;
hash_map<DWORD, GSTexture9> m_mskfix; hash_map<uint32, GSTexture9> m_mskfix;
public: public:
GSTextureFX9(); GSTextureFX9();
bool Create(GSDevice9* dev); bool Create(GSDevice9* dev);
bool CreateMskFix(GSTexture9& t, DWORD size, DWORD msk, DWORD fix); bool CreateMskFix(GSTexture9& t, uint32 size, uint32 msk, uint32 fix);
bool SetupIA(const GSVertexHW9* vertices, UINT count, D3DPRIMITIVETYPE prim); bool SetupIA(const GSVertexHW9* vertices, int count, D3DPRIMITIVETYPE prim);
bool SetupVS(VSSelector sel, const VSConstantBuffer* cb); bool SetupVS(VSSelector sel, const VSConstantBuffer* cb);
bool SetupPS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSelector ssel, IDirect3DTexture9* tex, IDirect3DTexture9* pal, bool psrr); bool SetupPS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSelector ssel, IDirect3DTexture9* tex, IDirect3DTexture9* pal, bool psrr);
void UpdatePS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSelector ssel, bool psrr); void UpdatePS(PSSelector sel, const PSConstantBuffer* cb, PSSamplerSelector ssel, bool psrr);
void SetupRS(int w, int h, const RECT& scissor); void SetupRS(int w, int h, const GSVector4i& scissor);
void SetupOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, BYTE bf, IDirect3DSurface9* rt, IDirect3DSurface9* ds); void SetupOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, uint8 bf, IDirect3DSurface9* rt, IDirect3DSurface9* ds);
void UpdateOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, BYTE bf); void UpdateOM(OMDepthStencilSelector dssel, OMBlendSelector bsel, uint8 bf);
}; };

4
plugins/GSdx/GSTextureNull.h
View File

@ -37,8 +37,8 @@ public:
int GetWidth() const {return m_desc.w;} int GetWidth() const {return m_desc.w;}
int GetHeight() const {return m_desc.h;} int GetHeight() const {return m_desc.h;}
int GetFormat() const {return m_desc.format;} int GetFormat() const {return m_desc.format;}
bool Update(const CRect& r, const void* data, int pitch) {return true;} bool Update(const GSVector4i& r, const void* data, int pitch) {return true;}
bool Map(BYTE** bits, int& pitch, const RECT* r = NULL) {return true;} bool Map(uint8** bits, int& pitch) {return true;}
void Unmap() {} void Unmap() {}
bool Save(const string& fn, bool dds = false) {return false;} bool Save(const string& fn, bool dds = false) {return false;}
}; };

63
plugins/GSdx/GSThread.cpp Normal file
View File

@ -0,0 +1,63 @@
/*
* Copyright (C) 2007-2009 Gabest
* http://www.gabest.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#include "StdAfx.h"
#include "GSThread.h"
GSThread::GSThread()
: m_ThreadId(0)
, m_hThread(NULL)
{
}
GSThread::~GSThread()
{
CloseThread();
}
DWORD WINAPI GSThread::StaticThreadProc(LPVOID lpParam)
{
((GSThread*)lpParam)->ThreadProc();
return 0;
}
void GSThread::CreateThread()
{
m_hThread = ::CreateThread(NULL, 0, StaticThreadProc, (LPVOID)this, 0, &m_ThreadId);
}
void GSThread::CloseThread()
{
if(m_hThread != NULL)
{
if(WaitForSingleObject(m_hThread, 5000) != WAIT_OBJECT_0)
{
TerminateThread(m_hThread, 1);
}
CloseHandle(m_hThread);
m_hThread = NULL;
m_ThreadId = 0;
}
}

42
plugins/GSdx/GSThread.h Normal file
View File

@ -0,0 +1,42 @@
/*
* Copyright (C) 2007-2009 Gabest
* http://www.gabest.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#pragma once
class GSThread
{
// TODO: linux
DWORD m_ThreadId;
HANDLE m_hThread;
static DWORD WINAPI StaticThreadProc(LPVOID lpParam);
protected:
virtual void ThreadProc() = 0;
void CreateThread();
void CloseThread();
public:
GSThread();
virtual ~GSThread();
};

119
plugins/GSdx/GSUtil.cpp
View File

@ -23,10 +23,11 @@
#include "GS.h" #include "GS.h"
#include "GSUtil.h" #include "GSUtil.h"
#include "svnrev.h" #include "svnrev.h"
#include "xbyak/xbyak_util.h"
static struct GSUtilMaps static struct GSUtilMaps
{ {
BYTE PrimClassField[8]; uint8 PrimClassField[8];
bool CompatibleBitsField[64][64]; bool CompatibleBitsField[64][64];
bool SharedBitsField[64][64]; bool SharedBitsField[64][64];
@ -72,80 +73,45 @@ static struct GSUtilMaps
} s_maps; } s_maps;
GS_PRIM_CLASS GSUtil::GetPrimClass(DWORD prim) GS_PRIM_CLASS GSUtil::GetPrimClass(uint32 prim)
{ {
return (GS_PRIM_CLASS)s_maps.PrimClassField[prim]; return (GS_PRIM_CLASS)s_maps.PrimClassField[prim];
} }
bool GSUtil::HasSharedBits(DWORD spsm, DWORD dpsm) bool GSUtil::HasSharedBits(uint32 spsm, uint32 dpsm)
{ {
return s_maps.SharedBitsField[spsm][dpsm]; return s_maps.SharedBitsField[spsm][dpsm];
} }
bool GSUtil::HasSharedBits(DWORD sbp, DWORD spsm, DWORD dbp, DWORD dpsm) bool GSUtil::HasSharedBits(uint32 sbp, uint32 spsm, uint32 dbp, uint32 dpsm)
{ {
if(sbp != dbp) return false; if(sbp != dbp) return false;
return HasSharedBits(spsm, dpsm); return HasSharedBits(spsm, dpsm);
} }
bool GSUtil::HasCompatibleBits(DWORD spsm, DWORD dpsm) bool GSUtil::HasCompatibleBits(uint32 spsm, uint32 dpsm)
{ {
if(spsm == dpsm) return true; if(spsm == dpsm) return true;
return s_maps.CompatibleBitsField[spsm][dpsm]; return s_maps.CompatibleBitsField[spsm][dpsm];
} }
bool GSUtil::IsRectInRect(const CRect& inner, const CRect& outer) bool GSUtil::IsRectInRect(const GSVector4i& inner, const GSVector4i& outer)
{ {
return outer.left <= inner.left && inner.right <= outer.right && outer.top <= inner.top && inner.bottom <= outer.bottom; return outer.left <= inner.left && inner.right <= outer.right && outer.top <= inner.top && inner.bottom <= outer.bottom;
} }
bool GSUtil::IsRectInRectH(const CRect& inner, const CRect& outer) bool GSUtil::IsRectInRectH(const GSVector4i& inner, const GSVector4i& outer)
{ {
return outer.top <= inner.top && inner.bottom <= outer.bottom; return outer.top <= inner.top && inner.bottom <= outer.bottom;
} }
bool GSUtil::IsRectInRectV(const CRect& inner, const CRect& outer) bool GSUtil::IsRectInRectV(const GSVector4i& inner, const GSVector4i& outer)
{ {
return outer.left <= inner.left && inner.right <= outer.right; return outer.left <= inner.left && inner.right <= outer.right;
} }
void GSUtil::FitRect(CRect& r, int aspectratio)
{
static const int ar[][2] = {{0, 0}, {4, 3}, {16, 9}};
if(aspectratio <= 0 || aspectratio >= countof(ar))
{
return;
}
int arx = ar[aspectratio][0];
int ary = ar[aspectratio][1];
CRect r2 = r;
if(arx > 0 && ary > 0)
{
if(r.Width() * ary > r.Height() * arx)
{
int w = r.Height() * arx / ary;
r.left = r.CenterPoint().x - w / 2;
if(r.left & 1) r.left++;
r.right = r.left + w;
}
else
{
int h = r.Width() * ary / arx;
r.top = r.CenterPoint().y - h / 2;
if(r.top & 1) r.top++;
r.bottom = r.top + h;
}
}
r &= r2;
}
bool GSUtil::CheckDirectX() bool GSUtil::CheckDirectX()
{ {
if(HINSTANCE hDll = LoadLibrary(format("d3dx9_%d.dll", D3DX_SDK_VERSION).c_str())) if(HINSTANCE hDll = LoadLibrary(format("d3dx9_%d.dll", D3DX_SDK_VERSION).c_str()))
@ -167,33 +133,22 @@ bool GSUtil::CheckDirectX()
return true; return true;
} }
static bool _CheckSSE()
{
__try
{
static __m128i m;
#if _M_SSE >= 0x402
m.m128i_i32[0] = _mm_popcnt_u32(1234);
#elif _M_SSE >= 0x401
m = _mm_packus_epi32(m, m);
#elif _M_SSE >= 0x301
m = _mm_alignr_epi8(m, m, 1);
#elif _M_SSE >= 0x200
m = _mm_packs_epi32(m, m);
#endif
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
return false;
}
return true;
}
bool GSUtil::CheckSSE() bool GSUtil::CheckSSE()
{ {
if(!_CheckSSE()) Xbyak::util::Cpu cpu;
Xbyak::util::Cpu::Type type;
#if _M_SSE >= 0x402
type = Xbyak::util::Cpu::tSSE42;
#elif _M_SSE >= 0x401
type = Xbyak::util::Cpu::tSSE41;
#elif _M_SSE >= 0x301
type = Xbyak::util::Cpu::tSSSE3;
#elif _M_SSE >= 0x200
type = Xbyak::util::Cpu::tSSE2;
#endif
if(!cpu.has(type))
{ {
string s = format("This CPU does not support SSE %d.%02d", _M_SSE >> 8, _M_SSE & 0xff); string s = format("This CPU does not support SSE %d.%02d", _M_SSE >> 8, _M_SSE & 0xff);
@ -223,29 +178,31 @@ char* GSUtil::GetLibName()
if(SVN_MODS) str += "m"; if(SVN_MODS) str += "m";
#if _M_AMD64 #if _M_AMD64
str += " 64-bit"; str += " 64-bit";
#endif #endif
list<string> sl; list<string> sl;
#ifdef __INTEL_COMPILER // TODO: gcc
sl.push_back(format("Intel C++ %d.%02d", __INTEL_COMPILER / 100, __INTEL_COMPILER % 100));
#elif _MSC_VER
sl.push_back(format("MSVC %d.%02d", _MSC_VER / 100, _MSC_VER % 100));
#endif
#if _M_SSE >= 0x402 #ifdef __INTEL_COMPILER
sl.push_back(format("Intel C++ %d.%02d", __INTEL_COMPILER / 100, __INTEL_COMPILER % 100));
#elif _MSC_VER
sl.push_back(format("MSVC %d.%02d", _MSC_VER / 100, _MSC_VER % 100));
#endif
#if _M_SSE >= 0x402
sl.push_back("SSE42"); sl.push_back("SSE42");
#elif _M_SSE >= 0x401 #elif _M_SSE >= 0x401
sl.push_back("SSE41"); sl.push_back("SSE41");
#elif _M_SSE >= 0x301 #elif _M_SSE >= 0x301
sl.push_back("SSSE3"); sl.push_back("SSSE3");
#elif _M_SSE >= 0x200 #elif _M_SSE >= 0x200
sl.push_back("SSE2"); sl.push_back("SSE2");
#elif _M_SSE >= 0x100 #elif _M_SSE >= 0x100
sl.push_back("SSE"); sl.push_back("SSE");
#endif #endif
for(list<string>::iterator i = sl.begin(); i != sl.end(); ) for(list<string>::iterator i = sl.begin(); i != sl.end(); )
{ {

18
plugins/GSdx/GSUtil.h
View File

@ -26,19 +26,17 @@
class GSUtil class GSUtil
{ {
public: public:
static GS_PRIM_CLASS GetPrimClass(DWORD prim); static GS_PRIM_CLASS GetPrimClass(uint32 prim);
static bool HasSharedBits(DWORD spsm, DWORD dpsm); static bool HasSharedBits(uint32 spsm, uint32 dpsm);
static bool HasSharedBits(DWORD sbp, DWORD spsm, DWORD dbp, DWORD dpsm); static bool HasSharedBits(uint32 sbp, uint32 spsm, uint32 dbp, uint32 dpsm);
static bool HasCompatibleBits(DWORD spsm, DWORD dpsm); static bool HasCompatibleBits(uint32 spsm, uint32 dpsm);
static bool IsRectInRect(const CRect& inner, const CRect& outer); static bool IsRectInRect(const GSVector4i& inner, const GSVector4i& outer);
static bool IsRectInRectH(const CRect& inner, const CRect& outer); static bool IsRectInRectH(const GSVector4i& inner, const GSVector4i& outer);
static bool IsRectInRectV(const CRect& inner, const CRect& outer); static bool IsRectInRectV(const GSVector4i& inner, const GSVector4i& outer);
static void FitRect(CRect& r, int aspectratio); static uint32 EncodePSM(uint32 psm)
static int EncodePSM(int psm)
{ {
switch(psm) switch(psm)
{ {

52
plugins/GSdx/GSVector.cpp
View File

@ -46,3 +46,55 @@ GSVector4 GSVector4::cast(const GSVector4i& v)
{ {
return GSVector4(_mm_castsi128_ps(v.m)); return GSVector4(_mm_castsi128_ps(v.m));
} }
GSVector4i GSVector4i::fit(int arx, int ary) const
{
GSVector4i r = *this;
if(arx > 0 && ary > 0)
{
int w = width();
int h = height();
if(w * ary > h * arx)
{
int w2 = w * arx / ary;
r.left = (r.left + r.right - w2) >> 1;
if(r.left & 1) r.left++;
r.right = r.left + w2;
}
else
{
int h2 = w * ary / arx;
r.top = (r.top + r.bottom - h2) >> 1;
if(r.top & 1) r.top++;
r.bottom = r.top + h2;
}
r = r.rintersect(*this);
}
else
{
r = *this;
}
return r;
}
GSVector4i GSVector4i::fit(int preset) const
{
GSVector4i r;
static const int ar[][2] = {{0, 0}, {4, 3}, {16, 9}};
if(preset > 0 && preset < countof(ar))
{
r = fit(ar[preset][0], ar[preset][1]);
}
else
{
r = *this;
}
return r;
}

162
plugins/GSdx/GSVector.h
View File

@ -29,9 +29,11 @@ public:
*this = v; *this = v;
} }
void operator = (const GSVector2T& v) const GSVector2T& operator = (const GSVector2T& v)
{ {
_mm_storel_epi64((__m128i*)this, _mm_loadl_epi64((__m128i*)&v)); _mm_storel_epi64((__m128i*)this, _mm_loadl_epi64((__m128i*)&v));
return *this;
} }
}; };
@ -47,16 +49,17 @@ public:
{ {
struct {int x, y, z, w;}; struct {int x, y, z, w;};
struct {int r, g, b, a;}; struct {int r, g, b, a;};
struct {int left, top, right, bottom;};
int v[4]; int v[4];
float f32[4]; float f32[4];
unsigned __int64 u64[2]; int8 i8[16];
__int8 i8[16]; int16 i16[8];
__int16 i16[8]; int32 i32[4];
__int32 i32[4]; int64 i64[2];
__int64 i64[2]; uint8 u8[16];
unsigned __int8 u8[16]; uint16 u16[8];
unsigned __int16 u16[8]; uint32 u32[4];
unsigned __int32 u32[4]; uint64 u64[2];
__m128i m; __m128i m;
}; };
@ -113,11 +116,6 @@ public:
this->m = m; this->m = m;
} }
explicit GSVector4i(const CRect& r)
{
*this = GSVector4i(r.left, r.top, r.right, r.bottom);
}
explicit GSVector4i(const GSVector4& v) explicit GSVector4i(const GSVector4& v)
{ {
*this = v; *this = v;
@ -140,29 +138,70 @@ public:
this->m = m; this->m = m;
} }
void operator = (const CRect& r)
{
m = GSVector4i(r);
}
operator __m128i() const operator __m128i() const
{ {
return m; return m;
} }
operator CRect() const // rect
int width() const
{ {
return *(CRect*)&m; return right - left;
} }
UINT32 rgba32() const int height() const
{
return bottom - top;
}
bool rempty() const
{
return (*this < zwzw()).mask() != 0x00ff;
}
GSVector4i runion(const GSVector4i& a) const
{
#if _M_SSE >= 0x401
return min_i32(a).upl64(max_i32(a).srl<8>());
#else
return GSVector4i(min(x, a.x), min(y, a.y), max(z, a.z), max(x, a.w));
#endif
}
GSVector4i rintersect(const GSVector4i& a) const
{
return sat_i32(a);
}
GSVector4i fit(int arx, int ary) const;
GSVector4i fit(int preset) const;
operator LPCRECT() const
{
return (LPCRECT)this;
}
operator LPRECT()
{
return (LPRECT)this;
}
//
uint32 rgba32() const
{ {
GSVector4i v = *this; GSVector4i v = *this;
v = v.ps32(v); v = v.ps32(v);
v = v.pu16(v); v = v.pu16(v);
return (UINT32)store(v); return (uint32)store(v);
} }
static GSVector4i cast(const GSVector4& v); static GSVector4i cast(const GSVector4& v);
@ -203,6 +242,32 @@ public:
return max_i32(a.xyxy()).min_i32(a.zwzw()); return max_i32(a.xyxy()).min_i32(a.zwzw());
} }
#else
GSVector4i sat_i32(const GSVector4i& a, const GSVector4i& b) const
{
GSVector4i v;
v.x = min(max(x, a.x), b.x);
v.y = min(max(y, a.y), b.y);
v.z = min(max(z, a.z), b.z);
v.w = min(max(x, a.w), b.w);
return v;
}
GSVector4i sat_i32(const GSVector4i& a) const
{
GSVector4i v;
v.x = min(max(x, a.x), b.z);
v.y = min(max(y, a.y), b.w);
v.z = min(max(z, a.x), b.z);
v.w = min(max(x, a.y), b.w);
return v;
}
#endif #endif
GSVector4i sat_u8(const GSVector4i& a, const GSVector4i& b) const GSVector4i sat_u8(const GSVector4i& a, const GSVector4i& b) const
@ -841,6 +906,18 @@ public:
return sll16(shift + 1).mul16hs(f); return sll16(shift + 1).mul16hs(f);
} }
bool eq(const GSVector4i& v) const
{
#if _M_SSE >= 0x401
// pxor, ptest, je
GSVector4i t = *this ^ v;
return _mm_testz_si128(t, t) != 0;
#else
// pcmpeqd, pmovmskb, cmp, je
return eq32(v).alltrue();
#endif
}
GSVector4i eq8(const GSVector4i& v) const GSVector4i eq8(const GSVector4i& v) const
{ {
return GSVector4i(_mm_cmpeq_epi8(m, v.m)); return GSVector4i(_mm_cmpeq_epi8(m, v.m));
@ -1357,7 +1434,7 @@ public:
dst[1] = gather8_4<8>(ptr); dst[1] = gather8_4<8>(ptr);
} }
__forceinline void gather8_8(const BYTE* RESTRICT ptr, GSVector4i* RESTRICT dst) const __forceinline void gather8_8(const uint8* RESTRICT ptr, GSVector4i* RESTRICT dst) const
{ {
dst[0] = gather8_8<>(ptr); dst[0] = gather8_8<>(ptr);
} }
@ -2077,16 +2154,17 @@ public:
{ {
struct {float x, y, z, w;}; struct {float x, y, z, w;};
struct {float r, g, b, a;}; struct {float r, g, b, a;};
struct {int left, top, right, bottom;};
float v[4]; float v[4];
float f32[4]; float f32[4];
unsigned __int64 u64[2]; int8 i8[16];
__int8 i8[16]; int16 i16[8];
__int16 i16[8]; int32 i32[4];
__int32 i32[4]; int64 i64[2];
__int64 i64[2]; uint8 u8[16];
unsigned __int8 u8[16]; uint16 u16[8];
unsigned __int16 u16[8]; uint32 u32[4];
unsigned __int32 u32[4]; uint64 u64[2];
__m128 m; __m128 m;
}; };
@ -2140,14 +2218,9 @@ public:
this->m = m; this->m = m;
} }
explicit GSVector4(CRect r) explicit GSVector4(uint32 u32)
{ {
m = _mm_set_ps((float)r.bottom, (float)r.right, (float)r.top, (float)r.left); *this = GSVector4(GSVector4i::load((int)u32).u8to32());
}
explicit GSVector4(DWORD dw)
{
*this = GSVector4(GSVector4i::load((int)dw).u8to32());
} }
explicit GSVector4(const GSVector4i& v) explicit GSVector4(const GSVector4i& v)
@ -2172,14 +2245,9 @@ public:
this->m = m; this->m = m;
} }
void operator = (DWORD dw) void operator = (uint32 u32)
{ {
*this = GSVector4(GSVector4i::load((int)dw).u8to32()); *this = GSVector4(GSVector4i::load((int)u32).u8to32());
}
void operator = (CRect r)
{
*this = GSVector4(GSVector4i(r.left, r.top, r.right, r.bottom));
} }
operator __m128() const operator __m128() const
@ -2187,7 +2255,7 @@ public:
return m; return m;
} }
UINT32 rgba32() const uint32 rgba32() const
{ {
return GSVector4i(*this).rgba32(); return GSVector4i(*this).rgba32();
} }

2
plugins/GSdx/GSVertex.h
View File

@ -48,7 +48,7 @@ __declspec(align(16)) struct GSVertex
GSVertex() {memset(this, 0, sizeof(*this));} GSVertex() {memset(this, 0, sizeof(*this));}
GSVector4 GetUV() const {return GSVector4(GSVector4i::load(UV.ai32[0]).upl16());} GSVector4 GetUV() const {return GSVector4(GSVector4i::load(UV.u32[0]).upl16());}
}; };
struct GSVertexOld struct GSVertexOld

22
plugins/GSdx/GSVertexHW.h
View File

@ -30,17 +30,19 @@ __declspec(align(16)) union GSVertexHW9
struct struct
{ {
GSVector2 t; GSVector2 t;
union {struct {BYTE r, g, b, a;}; DWORD c0;}; union {struct {uint8 r, g, b, a;}; uint32 c0;};
union {struct {BYTE ta0, ta1, res, f;}; DWORD c1;}; union {struct {uint8 ta0, ta1, res, f;}; uint32 c1;};
GSVector4 p; GSVector4 p;
}; };
#if _M_SSE >= 0x200
struct {__m128i m128i[2];}; struct {__m128i m128i[2];};
struct {__m128 m128[2];}; struct {__m128 m128[2];};
#if _M_SSE >= 0x200
GSVertexHW9& operator = (GSVertexHW9& v) {m128i[0] = v.m128i[0]; m128i[1] = v.m128i[1]; return *this;} GSVertexHW9& operator = (GSVertexHW9& v) {m128i[0] = v.m128i[0]; m128i[1] = v.m128i[1]; return *this;}
#endif
#endif
float GetQ() {return p.w;} float GetQ() {return p.w;}
}; };
@ -57,29 +59,31 @@ __declspec(align(16)) union GSVertexHW10
union union
{ {
struct {union {struct {WORD x, y;}; DWORD xy;}; DWORD z;} p; struct {union {struct {uint16 x, y;}; uint32 xy;}; uint32 z;} p;
GIFRegXYZ XYZ; GIFRegXYZ XYZ;
}; };
union union
{ {
union {struct {BYTE r, g, b, a; float q;}; DWORD c0;}; union {struct {uint8 r, g, b, a; float q;}; uint32 c0;};
GIFRegRGBAQ RGBAQ; GIFRegRGBAQ RGBAQ;
}; };
union union
{ {
struct {DWORD _pad[1]; union {struct {BYTE ta0, ta1, res, f;}; DWORD c1;};}; struct {uint32 _pad; union {struct {uint8 ta0, ta1, res, f;}; uint32 c1;};};
GIFRegFOG FOG; GIFRegFOG FOG;
}; };
}; };
#if _M_SSE >= 0x200
struct {__m128i m128i[2];}; struct {__m128i m128i[2];};
struct {__m128 m128[2];}; struct {__m128 m128[2];};
#if _M_SSE >= 0x200
GSVertexHW10& operator = (GSVertexHW10& v) {m128i[0] = v.m128i[0]; m128i[1] = v.m128i[1]; return *this;} GSVertexHW10& operator = (GSVertexHW10& v) {m128i[0] = v.m128i[0]; m128i[1] = v.m128i[1]; return *this;}
#endif
#endif
float GetQ() {return q;} float GetQ() {return q;}
}; };

4
plugins/GSdx/GSVertexList.h
View File

@ -25,7 +25,7 @@ template <class Vertex> class GSVertexList
{ {
void* m_base; void* m_base;
Vertex* m_v[3]; Vertex* m_v[3];
DWORD m_count; int m_count;
public: public:
GSVertexList() GSVertexList()
@ -80,7 +80,7 @@ public:
v = *m_v[i]; v = *m_v[i];
} }
DWORD GetCount() int GetCount()
{ {
return m_count; return m_count;
} }

10
plugins/GSdx/GSVertexSW.cpp
View File

@ -26,7 +26,7 @@
using namespace Xbyak; using namespace Xbyak;
GSVertexTrace::GSVertexTraceCodeGenerator::GSVertexTraceCodeGenerator(DWORD key, void* ptr, size_t maxsize) GSVertexTrace::GSVertexTraceCodeGenerator::GSVertexTraceCodeGenerator(uint32 key, void* ptr, size_t maxsize)
: CodeGenerator(maxsize, ptr) : CodeGenerator(maxsize, ptr)
{ {
#if _M_AMD64 #if _M_AMD64
@ -35,10 +35,10 @@ GSVertexTrace::GSVertexTraceCodeGenerator::GSVertexTraceCodeGenerator(DWORD key,
const int params = 0; const int params = 0;
DWORD primclass = (key >> 0) & 3; uint32 primclass = (key >> 0) & 3;
DWORD iip = (key >> 2) & 1; uint32 iip = (key >> 2) & 1;
DWORD tme = (key >> 3) & 1; uint32 tme = (key >> 3) & 1;
DWORD color = (key >> 4) & 1; uint32 color = (key >> 4) & 1;
int n = 1; int n = 1;

16
plugins/GSdx/GSVertexSW.h
View File

@ -222,16 +222,16 @@ __declspec(align(16)) class GSVertexTrace
class GSVertexTraceCodeGenerator : public Xbyak::CodeGenerator class GSVertexTraceCodeGenerator : public Xbyak::CodeGenerator
{ {
public: public:
GSVertexTraceCodeGenerator(DWORD key, void* ptr, size_t maxsize); GSVertexTraceCodeGenerator(uint32 key, void* ptr, size_t maxsize);
}; };
typedef void (*VertexTracePtr)(const GSVertexSW* v, int count, GSVertexSW& min, GSVertexSW& max); typedef void (*VertexTracePtr)(const GSVertexSW* v, int count, GSVertexSW& min, GSVertexSW& max);
class GSVertexTraceMap : public GSCodeGeneratorFunctionMap<GSVertexTraceCodeGenerator, DWORD, VertexTracePtr> class GSVertexTraceMap : public GSCodeGeneratorFunctionMap<GSVertexTraceCodeGenerator, uint32, VertexTracePtr>
{ {
public: public:
GSVertexTraceMap() : GSCodeGeneratorFunctionMap("VertexTrace") {} GSVertexTraceMap() : GSCodeGeneratorFunctionMap("VertexTrace") {}
GSVertexTraceCodeGenerator* Create(DWORD key, void* ptr, size_t maxsize) {return new GSVertexTraceCodeGenerator(key, ptr, maxsize);} GSVertexTraceCodeGenerator* Create(uint32 key, void* ptr, size_t maxsize) {return new GSVertexTraceCodeGenerator(key, ptr, maxsize);}
} m_map; } m_map;
public: public:
@ -241,14 +241,14 @@ public:
union union
{ {
DWORD value; uint32 value;
struct {DWORD x:1, y:1, z:1, f:1, s:1, t:1, q:1, _pad:1, r:1, g:1, b:1, a:1;}; struct {uint32 x:1, y:1, z:1, f:1, s:1, t:1, q:1, _pad:1, r:1, g:1, b:1, a:1;};
struct {DWORD xyzf:4, stq:4, rgba:4;}; struct {uint32 xyzf:4, stq:4, rgba:4;};
} m_eq; } m_eq;
void Update(const GSVertexSW* v, int count, GS_PRIM_CLASS primclass, DWORD iip, DWORD tme, DWORD tfx, DWORD tcc) void Update(const GSVertexSW* v, int count, GS_PRIM_CLASS primclass, uint32 iip, uint32 tme, uint32 tfx, uint32 tcc)
{ {
DWORD key = primclass | (iip << 2) | (tme << 3); uint32 key = primclass | (iip << 2) | (tme << 3);
if(!(tme && tfx == TFX_DECAL && tcc)) if(!(tme && tfx == TFX_DECAL && tcc))
{ {

3620
plugins/GSdx/GSdx_vs2008.vcproj
View File

File diff suppressed because it is too large Load Diff

80
plugins/GSdx/sse.h
View File

@ -1,80 +0,0 @@
/*
* Copyright (C) 2007-2009 Gabest
* http://www.gabest.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#pragma once
// sse2
#if _M_SSE >= 0x200
#include <xmmintrin.h>
#include <emmintrin.h>
#ifndef _MM_DENORMALS_ARE_ZERO
#define _MM_DENORMALS_ARE_ZERO 0x0040
#endif
#define MXCSR (_MM_DENORMALS_ARE_ZERO | _MM_MASK_MASK | _MM_ROUND_NEAREST | _MM_FLUSH_ZERO_ON)
#if _MSC_VER < 1500
__forceinline __m128i _mm_castps_si128(__m128 a) {return *(__m128i*)&a;}
__forceinline __m128 _mm_castsi128_ps(__m128i a) {return *(__m128*)&a;}
__forceinline __m128i _mm_castpd_si128(__m128d a) {return *(__m128i*)&a;}
__forceinline __m128d _mm_castsi128_pd(__m128i a) {return *(__m128d*)&a;}
__forceinline __m128d _mm_castps_pd(__m128 a) {return *(__m128d*)&a;}
__forceinline __m128 _mm_castpd_ps(__m128d a) {return *(__m128*)&a;}
#endif
#define _MM_TRANSPOSE4_SI128(row0, row1, row2, row3) \
{ \
__m128 tmp0 = _mm_shuffle_ps(_mm_castsi128_ps(row0), _mm_castsi128_ps(row1), 0x44); \
__m128 tmp2 = _mm_shuffle_ps(_mm_castsi128_ps(row0), _mm_castsi128_ps(row1), 0xEE); \
__m128 tmp1 = _mm_shuffle_ps(_mm_castsi128_ps(row2), _mm_castsi128_ps(row3), 0x44); \
__m128 tmp3 = _mm_shuffle_ps(_mm_castsi128_ps(row2), _mm_castsi128_ps(row3), 0xEE); \
(row0) = _mm_castps_si128(_mm_shuffle_ps(tmp0, tmp1, 0x88)); \
(row1) = _mm_castps_si128(_mm_shuffle_ps(tmp0, tmp1, 0xDD)); \
(row2) = _mm_castps_si128(_mm_shuffle_ps(tmp2, tmp3, 0x88)); \
(row3) = _mm_castps_si128(_mm_shuffle_ps(tmp2, tmp3, 0xDD)); \
}
#else
#error TODO: GSVector4 and GSRasterizer needs SSE2
#endif
// sse3
#if _M_SSE >= 0x301
#include <tmmintrin.h>
#endif
// sse4
#if _M_SSE >= 0x401
#include <smmintrin.h>
#endif

101
plugins/GSdx/stdafx.h
View File

@ -4,7 +4,7 @@
#pragma once #pragma once
#pragma warning(disable: 4996) #pragma warning(disable: 4996 4995 4324 4100)
#ifndef VC_EXTRALEAN #ifndef VC_EXTRALEAN
#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers #define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
@ -36,11 +36,9 @@
#include <afxcmn.h> // MFC support for Windows Common Controls #include <afxcmn.h> // MFC support for Windows Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT #endif // _AFX_NO_AFXCMN_SUPPORT
//#include <afxmt.h> //#include <afxmt.h>
#include <ddraw.h>
#include <d3d9.h> // stdc
#include <d3dx9.h>
#include <d3d10.h>
#include <d3dx10.h>
#include <math.h> #include <math.h>
#include <string> #include <string>
@ -54,13 +52,20 @@ using namespace stdext;
extern string format(const char* fmt, ...); extern string format(const char* fmt, ...);
#if !defined(_M_SSE) && (defined(_M_AMD64) || defined(_M_IX86_FP) && _M_IX86_FP >= 2) // syntactic sugar
#define _M_SSE 0x200
#endif
#include "sse.h" // put these into vc9/common7/ide/usertype.dat to have them highlighted
#define countof(a) (sizeof(a)/sizeof(a[0])) typedef unsigned char uint8;
typedef signed char int8;
typedef unsigned short uint16;
typedef signed short int16;
typedef unsigned int uint32;
typedef signed int int32;
typedef unsigned long long uint64;
typedef signed long long int64;
#define countof(a) (sizeof(a) / sizeof(a[0]))
#define EXPORT_C extern "C" __declspec(dllexport) void __stdcall #define EXPORT_C extern "C" __declspec(dllexport) void __stdcall
#define EXPORT_C_(type) extern "C" __declspec(dllexport) type __stdcall #define EXPORT_C_(type) extern "C" __declspec(dllexport) type __stdcall
@ -68,16 +73,80 @@ extern string format(const char* fmt, ...);
#ifndef RESTRICT #ifndef RESTRICT
#ifdef __INTEL_COMPILER #ifdef __INTEL_COMPILER
#define RESTRICT restrict #define RESTRICT restrict
#elif _MSC_VER >= 1400 #elif _MSC_VER >= 1400 // TODO: gcc
#define RESTRICT __restrict #define RESTRICT __restrict
#else #else
#define RESTRICT #define RESTRICT
#endif #endif
#endif #endif
#pragma warning(disable : 4995 4324 4100) // directx
#define D3DCOLORWRITEENABLE_RGB (D3DCOLORWRITEENABLE_RED|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_BLUE) #include <ddraw.h>
#define D3DCOLORWRITEENABLE_RGBA (D3DCOLORWRITEENABLE_RGB|D3DCOLORWRITEENABLE_ALPHA) #include <d3d9.h>
#include <d3dx9.h>
#include <d3d10.h>
#include <d3dx10.h>
#define D3DCOLORWRITEENABLE_RGBA (D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA)
// sse
#if !defined(_M_SSE) && (defined(_M_AMD64) || defined(_M_IX86_FP) && _M_IX86_FP >= 2)
#define _M_SSE 0x200
#endif
#if _M_SSE >= 0x200
#include <xmmintrin.h>
#include <emmintrin.h>
#ifndef _MM_DENORMALS_ARE_ZERO
#define _MM_DENORMALS_ARE_ZERO 0x0040
#endif
#define MXCSR (_MM_DENORMALS_ARE_ZERO | _MM_MASK_MASK | _MM_ROUND_NEAREST | _MM_FLUSH_ZERO_ON)
#if _MSC_VER < 1500
__forceinline __m128i _mm_castps_si128(__m128 a) {return *(__m128i*)&a;}
__forceinline __m128 _mm_castsi128_ps(__m128i a) {return *(__m128*)&a;}
__forceinline __m128i _mm_castpd_si128(__m128d a) {return *(__m128i*)&a;}
__forceinline __m128d _mm_castsi128_pd(__m128i a) {return *(__m128d*)&a;}
__forceinline __m128d _mm_castps_pd(__m128 a) {return *(__m128d*)&a;}
__forceinline __m128 _mm_castpd_ps(__m128d a) {return *(__m128*)&a;}
#endif
#define _MM_TRANSPOSE4_SI128(row0, row1, row2, row3) \
{ \
__m128 tmp0 = _mm_shuffle_ps(_mm_castsi128_ps(row0), _mm_castsi128_ps(row1), 0x44); \
__m128 tmp2 = _mm_shuffle_ps(_mm_castsi128_ps(row0), _mm_castsi128_ps(row1), 0xEE); \
__m128 tmp1 = _mm_shuffle_ps(_mm_castsi128_ps(row2), _mm_castsi128_ps(row3), 0x44); \
__m128 tmp3 = _mm_shuffle_ps(_mm_castsi128_ps(row2), _mm_castsi128_ps(row3), 0xEE); \
(row0) = _mm_castps_si128(_mm_shuffle_ps(tmp0, tmp1, 0x88)); \
(row1) = _mm_castps_si128(_mm_shuffle_ps(tmp0, tmp1, 0xDD)); \
(row2) = _mm_castps_si128(_mm_shuffle_ps(tmp2, tmp3, 0x88)); \
(row3) = _mm_castps_si128(_mm_shuffle_ps(tmp2, tmp3, 0xDD)); \
}
#else
#error TODO: GSVector4 and GSRasterizer needs SSE2
#endif
#if _M_SSE >= 0x301
#include <tmmintrin.h>
#endif
#if _M_SSE >= 0x401
#include <smmintrin.h>
#endif
#define QI(i) (riid == __uuidof(i)) ? GetInterface((i*)this, ppv) :

4
plugins/GSdx/xbyak/xbyak.h
View File

@ -62,7 +62,7 @@ enum {
DEFAULT_MAX_CODE_SIZE = 2048, DEFAULT_MAX_CODE_SIZE = 2048,
VERSION = 0x2070, /* 0xABCD = A.BC(D) */ VERSION = 0x2070, /* 0xABCD = A.BC(D) */
}; };
/*
#ifndef MIE_DEFINED_UINT32 #ifndef MIE_DEFINED_UINT32
#define MIE_DEFINED_UINT32 #define MIE_DEFINED_UINT32
#ifdef _MSC_VER #ifdef _MSC_VER
@ -81,7 +81,7 @@ enum {
#endif #endif
#endif #endif
#endif #endif
*/
enum Error { enum Error {
ERR_NONE = 0, ERR_NONE = 0,
ERR_BAD_ADDRESSING, ERR_BAD_ADDRESSING,