The-Homebrew-Cloud/dolphin
2
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-01-09 15:49:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

- Fixed: Crash when loading a rom with an unknown file extension.

Browse Source 
- Fixed: Crash when stopping a game.
- Improved: DirectX Plugin.

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@237 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
NunoRamiro 2008-08-17 19:28:24 +00:00
parent e3f3a7a41d
commit 8c132bdae5
19 changed files with 429 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/Core/Common/Src/FileUtil.cpp
View File

@ -28,7 +28,7 @@ bool File::IsDirectory(const std::string &filename) {
std::string SanitizePath(const std::string &filename) { std::string SanitizePath(const std::string &filename) {
std::string copy = filename; std::string copy = filename;
for (int i = 0; i < copy.size(); i++) for (size_t i = 0; i < copy.size(); i++)
if (copy[i] == '/') if (copy[i] == '/')
copy[i] = '\\'; copy[i] = '\\';
return copy; return copy;
@ -81,4 +81,4 @@ bool File::CreateDir(const std::string &path)
#else #else
// TODO: Insert POSIX code here. // TODO: Insert POSIX code here.
#endif #endif
} }

2
Source/Core/Common/Src/IniFile.cpp
View File

@ -323,7 +323,7 @@ bool IniFile::Load(const char* filename)
{ {
if (line[0] == '[') if (line[0] == '[')
{ {
int endpos = (int)line.find("]"); size_t endpos = line.find("]");
if (endpos != std::string::npos) if (endpos != std::string::npos)
{ {

2
Source/Core/Common/Src/x64Emitter.cpp
View File

@ -555,7 +555,7 @@ namespace Gen
} }
} }
void POP(int bits, const OpArg &reg) void POP(int /*bits*/, const OpArg &reg)
{ {
if (reg.IsSimpleReg()) if (reg.IsSimpleReg())
POP(reg.GetSimpleReg()); POP(reg.GetSimpleReg());

4
Source/Core/Core/Src/HW/EXI_DeviceMemoryCard.cpp
View File

@ -56,6 +56,7 @@ CEXIMemoryCard::CEXIMemoryCard(const std::string& _rName, const std::string& _rF
{ {
LOG(EXPANSIONINTERFACE, "No memory card found. Will create new."); LOG(EXPANSIONINTERFACE, "No memory card found. Will create new.");
Flush(); Flush();
Core::DisplayMessage(StringFromFormat("Wrote memory card contents to %s", m_strFilename.c_str()), 4000);
} }
formatDelay = 0; formatDelay = 0;
@ -84,14 +85,13 @@ void CEXIMemoryCard::Flush()
} }
fwrite(memory_card_content, memory_card_size, 1, pFile); fwrite(memory_card_content, memory_card_size, 1, pFile);
fclose(pFile); fclose(pFile);
Core::DisplayMessage(StringFromFormat("Wrote memory card contents to %s", m_strFilename.c_str()), 4000);
} }
void CEXIMemoryCard::FlushCallback(u64 userdata, int cyclesLate) void CEXIMemoryCard::FlushCallback(u64 userdata, int cyclesLate)
{ {
CEXIMemoryCard *ptr = reinterpret_cast<CEXIMemoryCard*>(userdata); CEXIMemoryCard *ptr = reinterpret_cast<CEXIMemoryCard*>(userdata);
ptr->Flush(); ptr->Flush();
Core::DisplayMessage(StringFromFormat("Wrote memory card contents to %s", ptr->GetFileName().c_str()), 4000);
} }

2
Source/Core/Core/Src/HW/EXI_DeviceMemoryCard.h
View File

@ -36,6 +36,8 @@ public:
//! Is device present? //! Is device present?
bool IsPresent(); bool IsPresent();
inline const std::string &GetFileName() const { return m_strFilename; };
private: private:
// This is scheduled whenever a page write is issued. The this pointer is passed // This is scheduled whenever a page write is issued. The this pointer is passed
// through the userdata parameter, so that it can then call Flush on the right card. // through the userdata parameter, so that it can then call Flush on the right card.

5
Source/Core/DolphinWX/src/BootManager.cpp
View File

@ -70,7 +70,10 @@ bool BootCore(const std::string& _rFilename)
#endif #endif
#endif #endif
StartUp.AutoSetup(SCoreStartupParameter::BOOT_DEFAULT); if ( !StartUp.AutoSetup(SCoreStartupParameter::BOOT_DEFAULT) )
{
return false;
}
// Load overrides // Load overrides
IniFile ini; IniFile ini;

2
Source/Core/DolphinWX/src/Frame.cpp
View File

@ -195,7 +195,7 @@ void CFrame::CreateMenu()
pOptionsMenu->Append(IDM_CONFIG_PAD_PLUGIN, _T("&PAD settings")); pOptionsMenu->Append(IDM_CONFIG_PAD_PLUGIN, _T("&PAD settings"));
pOptionsMenu->AppendSeparator(); pOptionsMenu->AppendSeparator();
pOptionsMenu->Append(IDM_TOGGLE_FULLSCREEN, _T("&Fullscreen")); pOptionsMenu->Append(IDM_TOGGLE_FULLSCREEN, _T("&Fullscreen"));
pOptionsMenu->AppendCheckItem(IDM_TOGGLE_DUALCORE, _T("&Dual-core (instable!)")); pOptionsMenu->AppendCheckItem(IDM_TOGGLE_DUALCORE, _T("&Dual-core (unstable!)"));
pOptionsMenu->Check(IDM_TOGGLE_DUALCORE, SConfig::GetInstance().m_LocalCoreStartupParameter.bUseDualCore); pOptionsMenu->Check(IDM_TOGGLE_DUALCORE, SConfig::GetInstance().m_LocalCoreStartupParameter.bUseDualCore);
pOptionsMenu->AppendCheckItem(IDM_TOGGLE_THROTTLE, _T("&Enable throttle")); pOptionsMenu->AppendCheckItem(IDM_TOGGLE_THROTTLE, _T("&Enable throttle"));
pOptionsMenu->Check(IDM_TOGGLE_THROTTLE, SConfig::GetInstance().m_LocalCoreStartupParameter.bThrottle); pOptionsMenu->Check(IDM_TOGGLE_THROTTLE, SConfig::GetInstance().m_LocalCoreStartupParameter.bThrottle);

100
Source/Plugins/Plugin_VideoDX9/Src/BPStructs.cpp
View File

@ -94,9 +94,15 @@ void BPWritten(int addr, int changes, int newval)
{ {
CVertexHandler::Flush(); CVertexHandler::Flush();
((u32*)&bpmem)[addr] = newval; ((u32*)&bpmem)[addr] = newval;
dev->SetRenderState(D3DRS_CULLMODE, d3dCullModes[bpmem.genMode.cullmode]);
// dev->SetRenderState(D3DRS_CULLMODE, d3dCullModes[bpmem.genMode.cullmode]);
Renderer::SetRenderState( D3DRS_CULLMODE, d3dCullModes[bpmem.genMode.cullmode] );
if (bpmem.genMode.cullmode == 3) if (bpmem.genMode.cullmode == 3)
dev->SetRenderState(D3DRS_COLORWRITEENABLE, 0); {
// dev->SetRenderState(D3DRS_COLORWRITEENABLE, 0);
Renderer::SetRenderState( D3DRS_COLORWRITEENABLE, 0 );
}
else else
{ {
DWORD write = 0; DWORD write = 0;
@ -104,7 +110,9 @@ void BPWritten(int addr, int changes, int newval)
write = D3DCOLORWRITEENABLE_ALPHA; write = D3DCOLORWRITEENABLE_ALPHA;
if (bpmem.blendmode.colorupdate) if (bpmem.blendmode.colorupdate)
write |= D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE; write |= D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE;
dev->SetRenderState(D3DRS_COLORWRITEENABLE, write);
// dev->SetRenderState(D3DRS_COLORWRITEENABLE, write);
Renderer::SetRenderState( D3DRS_COLORWRITEENABLE, write );
} }
} }
break; break;
@ -139,15 +147,22 @@ void BPWritten(int addr, int changes, int newval)
((u32*)&bpmem)[addr] = newval; ((u32*)&bpmem)[addr] = newval;
if (bpmem.zmode.testenable) if (bpmem.zmode.testenable)
{ {
dev->SetRenderState(D3DRS_ZENABLE, TRUE); // dev->SetRenderState(D3DRS_ZENABLE, TRUE);
dev->SetRenderState(D3DRS_ZWRITEENABLE, bpmem.zmode.updateenable); // dev->SetRenderState(D3DRS_ZWRITEENABLE, bpmem.zmode.updateenable);
dev->SetRenderState(D3DRS_ZFUNC,d3dCmpFuncs[bpmem.zmode.func]); // dev->SetRenderState(D3DRS_ZFUNC,d3dCmpFuncs[bpmem.zmode.func]);
Renderer::SetRenderState( D3DRS_ZENABLE, TRUE );
Renderer::SetRenderState( D3DRS_ZWRITEENABLE, bpmem.zmode.updateenable );
Renderer::SetRenderState( D3DRS_ZFUNC, d3dCmpFuncs[bpmem.zmode.func] );
} }
else else
{ {
// if the test is disabled write is disabled too // if the test is disabled write is disabled too
dev->SetRenderState(D3DRS_ZENABLE, FALSE); // dev->SetRenderState(D3DRS_ZENABLE, FALSE);
dev->SetRenderState(D3DRS_ZWRITEENABLE, FALSE); // dev->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
Renderer::SetRenderState( D3DRS_ZENABLE, FALSE );
Renderer::SetRenderState( D3DRS_ZWRITEENABLE, FALSE );
} }
} }
break; break;
@ -167,9 +182,13 @@ void BPWritten(int addr, int changes, int newval)
if (D3D::GetShaderVersion() == PSNONE) if (D3D::GetShaderVersion() == PSNONE)
{ {
dev->SetRenderState(D3DRS_ALPHATESTENABLE, (Compare)bpmem.alphaFunc.comp0 != COMPARE_ALWAYS); // dev->SetRenderState(D3DRS_ALPHATESTENABLE, (Compare)bpmem.alphaFunc.comp0 != COMPARE_ALWAYS);
dev->SetRenderState(D3DRS_ALPHAREF, bpmem.alphaFunc.ref0*4); // dev->SetRenderState(D3DRS_ALPHAREF, bpmem.alphaFunc.ref0*4);
dev->SetRenderState(D3DRS_ALPHAFUNC, d3dCmpFuncs[bpmem.alphaFunc.comp0]); // dev->SetRenderState(D3DRS_ALPHAFUNC, d3dCmpFuncs[bpmem.alphaFunc.comp0]);
Renderer::SetRenderState( D3DRS_ALPHATESTENABLE, (Compare)bpmem.alphaFunc.comp0 != COMPARE_ALWAYS );
Renderer::SetRenderState( D3DRS_ALPHAREF, bpmem.alphaFunc.ref0 * 4 );
Renderer::SetRenderState( D3DRS_ALPHAFUNC, d3dCmpFuncs[bpmem.alphaFunc.comp0] );
} }
// Normally, use texkill in pixel shader to emulate alpha test // Normally, use texkill in pixel shader to emulate alpha test
} }
@ -205,7 +224,11 @@ void BPWritten(int addr, int changes, int newval)
{ {
CVertexHandler::Flush(); CVertexHandler::Flush();
((u32*)&bpmem)[addr] = newval; ((u32*)&bpmem)[addr] = newval;
if (changes & 1) dev->SetRenderState(D3DRS_ALPHABLENDENABLE,bpmem.blendmode.blendenable); if (changes & 1)
{
// dev->SetRenderState(D3DRS_ALPHABLENDENABLE,bpmem.blendmode.blendenable);
Renderer::SetRenderState( D3DRS_ALPHABLENDENABLE, bpmem.blendmode.blendenable );
}
if (changes & 2) {} // Logic op blending. D3D can't do this but can fake some modes. if (changes & 2) {} // Logic op blending. D3D can't do this but can fake some modes.
if (changes & 4) { if (changes & 4) {
// Dithering is pointless. Will make things uglier and will be different from GC. // Dithering is pointless. Will make things uglier and will be different from GC.
@ -214,24 +237,42 @@ void BPWritten(int addr, int changes, int newval)
D3DBLEND src = d3dSrcFactors[bpmem.blendmode.srcfactor]; D3DBLEND src = d3dSrcFactors[bpmem.blendmode.srcfactor];
D3DBLEND dst = d3dDestFactors[bpmem.blendmode.dstfactor]; D3DBLEND dst = d3dDestFactors[bpmem.blendmode.dstfactor];
if (changes & 0x700) { if (changes & 0x700)
dev->SetRenderState(D3DRS_SRCBLEND, src); {
// dev->SetRenderState(D3DRS_SRCBLEND, src);
Renderer::SetRenderState( D3DRS_SRCBLEND, src );
} }
if (changes & 0xE0) { if (changes & 0xE0) {
if (!bpmem.blendmode.subtract) if (!bpmem.blendmode.subtract)
dev->SetRenderState(D3DRS_DESTBLEND, dst); {
// dev->SetRenderState(D3DRS_DESTBLEND, dst);
Renderer::SetRenderState( D3DRS_DESTBLEND, dst );
}
else else
dev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE); {
// dev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
Renderer::SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );
}
} }
if (changes & 0x800) { if (changes & 0x800) {
if (bpmem.blendmode.subtract) { if (bpmem.blendmode.subtract)
dev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE); {
dev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE); // dev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
} else { // dev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
dev->SetRenderState(D3DRS_SRCBLEND, src); Renderer::SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE );
dev->SetRenderState(D3DRS_DESTBLEND, dst); Renderer::SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );
} }
dev->SetRenderState(D3DRS_BLENDOP,bpmem.blendmode.subtract?D3DBLENDOP_SUBTRACT:D3DBLENDOP_ADD); else
{
// dev->SetRenderState(D3DRS_SRCBLEND, src);
// dev->SetRenderState(D3DRS_DESTBLEND, dst);
Renderer::SetRenderState( D3DRS_SRCBLEND, src );
Renderer::SetRenderState( D3DRS_DESTBLEND, dst );
}
// dev->SetRenderState(D3DRS_BLENDOP,bpmem.blendmode.subtract?D3DBLENDOP_SUBTRACT:D3DBLENDOP_ADD);
Renderer::SetRenderState( D3DRS_BLENDOP, bpmem.blendmode.subtract ? D3DBLENDOP_SUBTRACT : D3DBLENDOP_ADD );
} }
//if (bpmem.blendmode.logicopenable) // && bpmem.blendmode.logicmode == 4) //if (bpmem.blendmode.logicopenable) // && bpmem.blendmode.logicmode == 4)
// MessageBox(0,"LOGIC",0,0); // MessageBox(0,"LOGIC",0,0);
@ -244,7 +285,9 @@ void BPWritten(int addr, int changes, int newval)
write = D3DCOLORWRITEENABLE_ALPHA; write = D3DCOLORWRITEENABLE_ALPHA;
if (bpmem.blendmode.colorupdate) if (bpmem.blendmode.colorupdate)
write |= D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE; write |= D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE;
dev->SetRenderState(D3DRS_COLORWRITEENABLE, write);
// dev->SetRenderState(D3DRS_COLORWRITEENABLE, write);
Renderer::SetRenderState( D3DRS_COLORWRITEENABLE, write );
} }
} }
break; break;
@ -281,7 +324,9 @@ void BPWritten(int addr, int changes, int newval)
{ {
CVertexHandler::Flush(); CVertexHandler::Flush();
((u32*)&bpmem)[addr] = newval; ((u32*)&bpmem)[addr] = newval;
dev->SetRenderState(D3DRS_FOGCOLOR,bpmem.fog.color);
// dev->SetRenderState(D3DRS_FOGCOLOR,bpmem.fog.color);
Renderer::SetRenderState( D3DRS_FOGCOLOR, bpmem.fog.color );
} }
break; break;
@ -315,7 +360,10 @@ void BPWritten(int addr, int changes, int newval)
char temp[256]; char temp[256];
sprintf(temp,"ScissorRect: %i %i %i %i",rc.left,rc.top,rc.right,rc.bottom); sprintf(temp,"ScissorRect: %i %i %i %i",rc.left,rc.top,rc.right,rc.bottom);
g_VideoInitialize.pLog(temp, FALSE); g_VideoInitialize.pLog(temp, FALSE);
dev->SetRenderState(D3DRS_SCISSORTESTENABLE,TRUE);
// dev->SetRenderState(D3DRS_SCISSORTESTENABLE,TRUE);
Renderer::SetRenderState( D3DRS_SCISSORTESTENABLE, TRUE );
Renderer::SetScissorBox(rc); Renderer::SetScissorBox(rc);
} }
break; break;

37
Source/Plugins/Plugin_VideoDX9/Src/D3DBase.cpp
View File

@ -1,4 +1,6 @@
#include "D3DBase.h" #include "D3DBase.h"
#include "Render.h"
namespace D3D namespace D3D
{ {
@ -10,16 +12,14 @@ namespace D3D
int multisample; int multisample;
int resolution; int resolution;
#define VENDOR_NVIDIA 4318 #define VENDOR_NVIDIA 4318
RECT client; RECT client;
HWND hWnd; HWND hWnd;
int xres, yres; int xres, yres;
int cur_adapter; int cur_adapter;
int psMajor; Shader Ps;
int psMinor; Shader Vs;
int vsMajor;
int vsMinor;
bool bFrameInProgress = false; bool bFrameInProgress = false;
@ -56,7 +56,8 @@ namespace D3D
void EnableAlphaToCoverage() void EnableAlphaToCoverage()
{ {
dev->SetRenderState(D3DRS_ADAPTIVETESS_Y, (D3DFORMAT)MAKEFOURCC('A', 'T', 'O', 'C')); // dev->SetRenderState(D3DRS_ADAPTIVETESS_Y, (D3DFORMAT)MAKEFOURCC('A', 'T', 'O', 'C'));
Renderer::SetRenderState( D3DRS_ADAPTIVETESS_Y, (D3DFORMAT)MAKEFOURCC('A', 'T', 'O', 'C') );
} }
void InitPP(int adapter, int resolution, int aa_mode, D3DPRESENT_PARAMETERS *pp) void InitPP(int adapter, int resolution, int aa_mode, D3DPRESENT_PARAMETERS *pp)
@ -234,10 +235,10 @@ namespace D3D
dev->GetDeviceCaps(&caps); dev->GetDeviceCaps(&caps);
dev->GetRenderTarget(0,&backBuffer); dev->GetRenderTarget(0,&backBuffer);
psMajor = (D3D::caps.PixelShaderVersion >> 8) & 0xFF; Ps.Major = (D3D::caps.PixelShaderVersion >> 8) & 0xFF;
psMinor = (D3D::caps.PixelShaderVersion) & 0xFF; Ps.Minor = (D3D::caps.PixelShaderVersion) & 0xFF;
vsMajor = (D3D::caps.VertexShaderVersion >>8) & 0xFF; Vs.Major = (D3D::caps.VertexShaderVersion >>8) & 0xFF;
vsMinor = (D3D::caps.VertexShaderVersion) & 0xFF; Vs.Minor = (D3D::caps.VertexShaderVersion) & 0xFF;
// Device state would normally be set here // Device state would normally be set here
return S_OK; return S_OK;
@ -245,12 +246,14 @@ namespace D3D
ShaderVersion GetShaderVersion() ShaderVersion GetShaderVersion()
{ {
if (psMajor < 2) if (Ps.Major < 2)
{
return PSNONE; return PSNONE;
else }
//good enough estimate - we really only
//care about zero shader vs ps20 //good enough estimate - we really only
return (ShaderVersion)psMajor; //care about zero shader vs ps20
return (ShaderVersion)Ps.Major;
} }
void Close() void Close()
@ -328,8 +331,10 @@ namespace D3D
bool BeginFrame(bool clear, u32 color, float z) bool BeginFrame(bool clear, u32 color, float z)
{ {
if (bFrameInProgress) if (bFrameInProgress)
{
return false; return false;
}
bFrameInProgress = true; bFrameInProgress = true;

21
Source/Plugins/Plugin_VideoDX9/Src/D3DBase.h
View File

@ -16,10 +16,10 @@ namespace D3D
{ {
enum ShaderVersion enum ShaderVersion
{ {
PSNONE=0, PSNONE = 0,
PS20=2, PS20 = 2,
PS30, PS30 = 3,
PS40, PS40 = 4,
}; };
HRESULT Init(); HRESULT Init();
@ -41,11 +41,6 @@ namespace D3D
void ShowD3DError(HRESULT err); void ShowD3DError(HRESULT err);
void EnableAlphaToCoverage(); void EnableAlphaToCoverage();
extern int psMajor;
extern int psMinor;
extern int vsMajor;
extern int vsMinor;
struct Resolution struct Resolution
{ {
char name[32]; char name[32];
@ -70,10 +65,16 @@ namespace D3D
std::vector<AALevel> aa_levels; std::vector<AALevel> aa_levels;
bool supports_alpha_to_coverage; bool supports_alpha_to_coverage;
}; };
struct Shader
{
int Minor;
int Major;
};
const Adapter &GetAdapter(int i); const Adapter &GetAdapter(int i);
const Adapter &GetCurAdapter(); const Adapter &GetCurAdapter();
int GetNumAdapters(); int GetNumAdapters();
} }
#endif #endif

99
Source/Plugins/Plugin_VideoDX9/Src/D3DPostprocess.cpp
View File

@ -6,6 +6,8 @@
#include "Globals.h" #include "Globals.h"
#include "Render.h"
using namespace D3D; using namespace D3D;
namespace Postprocess namespace Postprocess
@ -97,7 +99,10 @@ namespace Postprocess
CreateStuff(); CreateStuff();
dev->SetRenderTarget(0,mainColorBuffer); dev->SetRenderTarget(0,mainColorBuffer);
dev->SetDepthStencilSurface(mainZStencilBuffer); dev->SetDepthStencilSurface(mainZStencilBuffer);
dev->SetRenderState(D3DRS_ZENABLE,TRUE);
// dev->SetRenderState(D3DRS_ZENABLE,TRUE);
Renderer::SetRenderState( D3DRS_ZENABLE, TRUE );
dev->Clear(0,0,D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,0,1,0); dev->Clear(0,0,D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,0,1,0);
} }
else else
@ -108,26 +113,33 @@ namespace Postprocess
dev->SetDepthStencilSurface(displayZStencilBuffer); dev->SetDepthStencilSurface(displayZStencilBuffer);
DestroyStuff(); DestroyStuff();
} }
dev->SetRenderState(D3DRS_ZENABLE,TRUE);
// dev->SetRenderState(D3DRS_ZENABLE,TRUE);
Renderer::SetRenderState( D3DRS_ZENABLE, TRUE );
} }
} }
int filterKernel[8] = {0x40,0x80,0xc0,0xFF,0xFF,0xc0,0x80,0x40}; //goodlooking almostgaussian int filterKernel[8] = {0x40,0x80,0xc0,0xFF,0xFF,0xc0,0x80,0x40}; //good looking almost Gaussian
//int filterKernel[8] = {0xFF,0xc0,0x80,0x40,0x40,0x80,0xc0,0xFF,}; //crazy filter //int filterKernel[8] = {0xFF,0xc0,0x80,0x40,0x40,0x80,0xc0,0xFF,}; //crazy filter
void NightGlow(bool intense, bool original) void NightGlow(bool intense, bool original)
{ {
dev->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_SUBTRACT); // dev->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_SUBTRACT);
// dev->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
dev->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE); // dev->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_ONE);
dev->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_ONE); // dev->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);
dev->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE); Renderer::SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SUBTRACT );
Renderer::SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
Renderer::SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE );
Renderer::SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );
dev->SetDepthStencilSurface(0); dev->SetDepthStencilSurface(0);
dev->SetTexture(0,mainColorBufferTexture); //dev->SetTexture(0,mainColorBufferTexture);
Renderer::SetTexture( 0, mainColorBufferTexture );
dev->SetRenderTarget(0,scratchSurface[0]); dev->SetRenderTarget(0,scratchSurface[0]);
dev->SetSamplerState(0,D3DSAMP_ADDRESSU,D3DTADDRESS_CLAMP); dev->SetSamplerState(0,D3DSAMP_ADDRESSU,D3DTADDRESS_CLAMP);
dev->SetSamplerState(0,D3DSAMP_ADDRESSV,D3DTADDRESS_CLAMP); dev->SetSamplerState(0,D3DSAMP_ADDRESSV,D3DTADDRESS_CLAMP);
@ -144,9 +156,11 @@ namespace Postprocess
float f=0.008f; float f=0.008f;
QOFF(0,0,0xa0a0a0a0); QOFF(0,0,0xa0a0a0a0);
dev->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE); // dev->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE);
//dev->SetTexture(0,scratch[0]);
Renderer::SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
Renderer::SetTexture( 0, scratch[0] );
dev->SetTexture(0,scratch[0]);
dev->SetRenderTarget(0,scratchSurface[1]); dev->SetRenderTarget(0,scratchSurface[1]);
dev->Clear(0,0,D3DCLEAR_TARGET,0,0,0); dev->Clear(0,0,D3DCLEAR_TARGET,0,0,0);
@ -159,7 +173,9 @@ namespace Postprocess
QOFF(0,(i-3.5f) * f * yMul,c); QOFF(0,(i-3.5f) * f * yMul,c);
} }
dev->SetTexture(0,scratch[1]); //dev->SetTexture(0,scratch[1]);
Renderer::SetTexture( 0, scratch[1] );
dev->SetRenderTarget(0,scratchSurface[0]); dev->SetRenderTarget(0,scratchSurface[0]);
dev->Clear(0,0,D3DCLEAR_TARGET,0,0,0); dev->Clear(0,0,D3DCLEAR_TARGET,0,0,0);
for (int i=0; i<8; i++) for (int i=0; i<8; i++)
@ -170,23 +186,33 @@ namespace Postprocess
QOFF((i-3.5f) * f,0,c); QOFF((i-3.5f) * f,0,c);
} }
dev->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE); // dev->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE);
Renderer::SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
if (intense) if (intense)
{ {
dev->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_ONE); // dev->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_ONE);
dev->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_SRCALPHA); // dev->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_SRCALPHA);
Renderer::SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE );
Renderer::SetRenderState( D3DRS_DESTBLEND, D3DBLEND_SRCALPHA );
} }
else else
{ {
dev->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_INVDESTCOLOR); // dev->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_INVDESTCOLOR);
dev->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE); // dev->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);
Renderer::SetRenderState( D3DRS_SRCBLEND, D3DBLEND_INVDESTCOLOR );
Renderer::SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );
} }
dev->SetTexture(0,scratch[0]); // dev->SetTexture(0,scratch[0]);
Renderer::SetTexture( 0, scratch[0] );
dev->SetRenderTarget(0,mainColorBuffer); dev->SetRenderTarget(0,mainColorBuffer);
quad2d(0,0,(float)mainWidth,(float)mainHeight,original?0xCFFFFFFF:0xFFFFFFFF,0,0,1,1); quad2d(0,0,(float)mainWidth,(float)mainHeight,original?0xCFFFFFFF:0xFFFFFFFF,0,0,1,1);
dev->SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);
// dev->SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);
Renderer::SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
dev->SetSamplerState(0,D3DSAMP_ADDRESSU,D3DTADDRESS_WRAP); dev->SetSamplerState(0,D3DSAMP_ADDRESSU,D3DTADDRESS_WRAP);
dev->SetSamplerState(0,D3DSAMP_ADDRESSV,D3DTADDRESS_WRAP); dev->SetSamplerState(0,D3DSAMP_ADDRESSV,D3DTADDRESS_WRAP);
//dev->SetSamplerState(0,D3DSAMP_MIPMAPLODBIAS,0); //dev->SetSamplerState(0,D3DSAMP_MIPMAPLODBIAS,0);
@ -208,15 +234,25 @@ namespace Postprocess
{ {
if (initialized) if (initialized)
{ {
dev->SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE); // dev->SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE);
dev->SetRenderState(D3DRS_ZENABLE,FALSE); // dev->SetRenderState(D3DRS_ZENABLE,FALSE);
dev->SetRenderState(D3DRS_FOGENABLE,FALSE); // dev->SetRenderState(D3DRS_FOGENABLE,FALSE);
dev->SetTextureStageState(0,D3DTSS_COLORARG1,D3DTA_TEXTURE); // dev->SetTextureStageState(0,D3DTSS_COLORARG1,D3DTA_TEXTURE);
dev->SetTextureStageState(0,D3DTSS_COLORARG2,D3DTA_DIFFUSE); // dev->SetTextureStageState(0,D3DTSS_COLORARG2,D3DTA_DIFFUSE);
dev->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE); // dev->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE);
dev->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TEXTURE); // dev->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TEXTURE);
dev->SetTextureStageState(0,D3DTSS_ALPHAARG2,D3DTA_DIFFUSE); // dev->SetTextureStageState(0,D3DTSS_ALPHAARG2,D3DTA_DIFFUSE);
dev->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG2); // dev->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG2);
Renderer::SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
Renderer::SetRenderState( D3DRS_ZENABLE, FALSE );
Renderer::SetRenderState( D3DRS_FOGENABLE, FALSE );
Renderer::SetTextureStageState(0,D3DTSS_COLORARG1,D3DTA_TEXTURE);
Renderer::SetTextureStageState(0,D3DTSS_COLORARG2,D3DTA_DIFFUSE);
Renderer::SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE);
Renderer::SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TEXTURE);
Renderer::SetTextureStageState(0,D3DTSS_ALPHAARG2,D3DTA_DIFFUSE);
Renderer::SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG2);
switch(g_Config.iPostprocessEffect) { switch(g_Config.iPostprocessEffect) {
case 1: case 1:
@ -231,8 +267,11 @@ namespace Postprocess
dev->SetRenderTarget(0,displayColorBuffer); dev->SetRenderTarget(0,displayColorBuffer);
dev->SetDepthStencilSurface(displayZStencilBuffer); dev->SetDepthStencilSurface(displayZStencilBuffer);
dev->SetTexture(0,mainColorBufferTexture);
// dev->SetTexture(0,mainColorBufferTexture);
Renderer::SetTexture( 0, mainColorBufferTexture );
quad2d(0, 0, (float)displayWidth, (float)displayHeight, 0xFFFFFFFF); quad2d(0, 0, (float)displayWidth, (float)displayHeight, 0xFFFFFFFF);
} }
} }
} }

56
Source/Plugins/Plugin_VideoDX9/Src/D3DUtil.cpp
View File

@ -2,6 +2,7 @@
#include "D3DBase.h" #include "D3DBase.h"
#include "D3DUtil.h" #include "D3DUtil.h"
#include "Render.h"
namespace D3D namespace D3D
{ {
@ -194,27 +195,44 @@ namespace D3D
void CD3DFont::SetRenderStates() void CD3DFont::SetRenderStates()
{ {
dev->SetTexture(0, m_pTexture); // dev->SetTexture(0, m_pTexture);
Renderer::SetTexture( 0, m_pTexture );
dev->SetPixelShader(0); dev->SetPixelShader(0);
dev->SetVertexShader(0); dev->SetVertexShader(0);
dev->SetVertexDeclaration(0); dev->SetVertexDeclaration(0);
dev->SetFVF(D3DFVF_FONT2DVERTEX);
// dev->SetFVF(D3DFVF_FONT2DVERTEX);
Renderer::SetFVF(D3DFVF_FONT2DVERTEX);
for (int i = 0; i < 6; i++) { for (int i = 0; i < 6; i++) {
dev->SetRenderState((_D3DRENDERSTATETYPE)RS[i][0],RS[i][1]); // dev->SetRenderState((_D3DRENDERSTATETYPE)RS[i][0],RS[i][1]);
dev->SetTextureStageState(0, (_D3DTEXTURESTAGESTATETYPE)int(TS[i][0]), TS[i][1]); // dev->SetTextureStageState(0, (_D3DTEXTURESTAGESTATETYPE)int(TS[i][0]), TS[i][1]);
Renderer::SetRenderState( (_D3DRENDERSTATETYPE)RS[i][0], RS[i][1] );
Renderer::SetTextureStageState( 0, (_D3DTEXTURESTAGESTATETYPE)int(TS[i][0]), TS[i][1] );
} }
} }
void RestoreRenderStates() void RestoreRenderStates()
{ {
dev->SetTexture(0, texture_old); // dev->SetTexture(0, texture_old);
Renderer::SetTexture( 0, texture_old );
dev->SetPixelShader(ps_old); dev->SetPixelShader(ps_old);
dev->SetVertexShader(vs_old); dev->SetVertexShader(vs_old);
dev->SetVertexDeclaration(decl_old); dev->SetVertexDeclaration(decl_old);
dev->SetFVF(FVF_old);
for (int i = 0; i < 6; i++) { // dev->SetFVF(FVF_old);
dev->SetRenderState((_D3DRENDERSTATETYPE)RS[i][0], RS_old[i]); Renderer::SetFVF(FVF_old);
dev->SetTextureStageState(0, (_D3DTEXTURESTAGESTATETYPE)int(TS[i][0]), TS_old[i]);
for (int i = 0; i < 6; i++)
{
// dev->SetRenderState((_D3DRENDERSTATETYPE)RS[i][0], RS_old[i]);
// dev->SetTextureStageState(0, (_D3DTEXTURESTAGESTATETYPE)int(TS[i][0]), TS_old[i]);
Renderer::SetRenderState( (_D3DRENDERSTATETYPE)RS[i][0], RS_old[i] );
Renderer::SetTextureStageState( 0, (_D3DTEXTURESTAGESTATETYPE)int(TS[i][0]), TS_old[i] );
} }
} }
@ -312,11 +330,14 @@ namespace D3D
pVertices+=6; pVertices+=6;
dwNumTriangles += 2; dwNumTriangles += 2;
if( dwNumTriangles*3 > (MAX_NUM_VERTICES-6) ) if( dwNumTriangles * 3 > (MAX_NUM_VERTICES-6) )
{ {
// Unlock, render, and relock the vertex buffer // Unlock, render, and relock the vertex buffer
m_pVB->Unlock(); m_pVB->Unlock();
dev->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
// dev->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
Renderer::DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
m_pVB->Lock( 0, 0, (void**)&pVertices, D3DLOCK_DISCARD ); m_pVB->Lock( 0, 0, (void**)&pVertices, D3DLOCK_DISCARD );
dwNumTriangles = 0; dwNumTriangles = 0;
} }
@ -327,7 +348,10 @@ namespace D3D
// Unlock and render the vertex buffer // Unlock and render the vertex buffer
m_pVB->Unlock(); m_pVB->Unlock();
if( dwNumTriangles > 0 ) if( dwNumTriangles > 0 )
dev->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles ); {
// dev->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
Renderer::DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
}
RestoreRenderStates(); RestoreRenderStates();
return S_OK; return S_OK;
} }
@ -344,8 +368,12 @@ namespace D3D
dev->SetPixelShader(0); dev->SetPixelShader(0);
dev->SetVertexShader(0); dev->SetVertexShader(0);
dev->SetVertexDeclaration(0); dev->SetVertexDeclaration(0);
dev->SetFVF(D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1);
dev->DrawPrimitiveUP(D3DPT_TRIANGLEFAN,2,coords,sizeof(Q2DVertex)); // dev->SetFVF(D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1);
// dev->DrawPrimitiveUP(D3DPT_TRIANGLEFAN,2,coords,sizeof(Q2DVertex));
Renderer::SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1);
Renderer::DrawPrimitiveUP(D3DPT_TRIANGLEFAN,2,coords,sizeof(Q2DVertex));
RestoreRenderStates(); RestoreRenderStates();
} }

117
Source/Plugins/Plugin_VideoDX9/Src/Render.cpp
View File

@ -2,8 +2,6 @@
#include "Common.h" #include "Common.h"
#include "D3DBase.h"
#include "Globals.h" #include "Globals.h"
#include "main.h" #include "main.h"
#include "VertexHandler.h" #include "VertexHandler.h"
@ -19,21 +17,29 @@
#include "EmuWindow.h" #include "EmuWindow.h"
#include <list> #include <list>
using namespace std;
float Renderer::m_x,Renderer::m_y,Renderer::m_width, Renderer::m_height, Renderer::xScale,Renderer::yScale; float Renderer::m_x,Renderer::m_y,Renderer::m_width, Renderer::m_height, Renderer::xScale,Renderer::yScale;
std::vector<LPDIRECT3DBASETEXTURE9> Renderer::m_Textures;
DWORD Renderer::m_RenderStates[MaxRenderStates];
DWORD Renderer::m_TextureStageStates[MaxTextureStages][MaxTextureTypes];
DWORD Renderer::m_SamplerStates[MaxSamplerSize][MaxSamplerTypes];
DWORD Renderer::m_FVF;
#define NUMWNDRES 6 #define NUMWNDRES 6
extern int g_Res[NUMWNDRES][2]; extern int g_Res[NUMWNDRES][2];
struct MESSAGE
struct Message
{ {
MESSAGE() {} Message(const std::string &msg, u32 dw) : message( msg ), dwTimeStamp( dw )
MESSAGE(const char* p, u32 dw) { strcpy(str, p); dwTimeStamp = dw; } {
char str[255]; }
std::string message;
u32 dwTimeStamp; u32 dwTimeStamp;
}; };
static std::list<MESSAGE> s_listMsgs; static std::list<Message> s_listMsgs;
void Renderer::Init(SVideoInitialize &_VideoInitialize) void Renderer::Init(SVideoInitialize &_VideoInitialize)
{ {
@ -64,11 +70,14 @@ void Renderer::Shutdown(void)
void Renderer::Initialize(void) void Renderer::Initialize(void)
{ {
D3D::dev->SetRenderState(D3DRS_LIGHTING,FALSE); m_FVF = 0;
D3D::dev->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
D3D::dev->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE); m_Textures.reserve( MaxTextureStages );
D3D::dev->SetRenderState(D3DRS_FOGENABLE, FALSE); for ( int i = 0; i < MaxTextureStages; i++ )
D3D::dev->SetRenderState(D3DRS_FILLMODE, g_Config.bWireFrame?D3DFILL_WIREFRAME:D3DFILL_SOLID); {
m_Textures.push_back( NULL );
}
for (int i=0; i<8; i++) for (int i=0; i<8; i++)
{ {
D3D::dev->SetSamplerState(i, D3DSAMP_MAXANISOTROPY, 16); D3D::dev->SetSamplerState(i, D3DSAMP_MAXANISOTROPY, 16);
@ -81,16 +90,16 @@ void Renderer::Initialize(void)
CVertexHandler::BeginFrame(); CVertexHandler::BeginFrame();
} }
void Renderer::AddMessage(const char* pstr, u32 ms) void Renderer::AddMessage(const std::string &message, u32 ms)
{ {
s_listMsgs.push_back(MESSAGE(pstr, timeGetTime()+ms)); s_listMsgs.push_back(Message(message, timeGetTime()+ms));
} }
void Renderer::ProcessMessages() void Renderer::ProcessMessages()
{ {
if (s_listMsgs.size() > 0) { if (s_listMsgs.size() > 0) {
int left = 25, top = 15; int left = 25, top = 15;
list<MESSAGE>::iterator it = s_listMsgs.begin(); std::list<Message>::iterator it = s_listMsgs.begin();
while( it != s_listMsgs.end() ) while( it != s_listMsgs.end() )
{ {
@ -105,8 +114,8 @@ void Renderer::ProcessMessages()
alpha <<= 24; alpha <<= 24;
RenderText(it->str, left+1, top+1, 0x000000|alpha); RenderText(it->message, left+1, top+1, 0x000000|alpha);
RenderText(it->str, left, top, 0xffff30|alpha); RenderText(it->message, left, top, 0xffff30|alpha);
top += 15; top += 15;
if (time_left <= 0) if (time_left <= 0)
@ -116,9 +125,9 @@ void Renderer::ProcessMessages()
} }
} }
void Renderer::RenderText(const char* pstr, int left, int top, u32 color) void Renderer::RenderText(const std::string &text, int left, int top, u32 color)
{ {
D3D::font.DrawTextScaled(left,top,20,20,0.0f,color,pstr,false); D3D::font.DrawTextScaled((float)left, (float)top, 20, 20, 0.0f, color, text.c_str(), false);
} }
void dumpMatrix(D3DXMATRIX &mtx) void dumpMatrix(D3DXMATRIX &mtx)
@ -250,7 +259,7 @@ void Renderer::SwapBuffers(void)
CVertexHandler::BeginFrame(); CVertexHandler::BeginFrame();
if (g_Config.bOldCard) if (g_Config.bOldCard)
D3D::font.SetRenderStates(); //compatibility with lowend cards D3D::font.SetRenderStates(); //compatibility with low end cards
} }
void Renderer::Flush(void) void Renderer::Flush(void)
@ -359,4 +368,66 @@ void Renderer::SetProjection(float* pMatrix, int constantIndex)
mtx.m[3][3] = 1.0f; mtx.m[3][3] = 1.0f;
} }
D3D::dev->SetVertexShaderConstantF(constantIndex, mtx, 4); D3D::dev->SetVertexShaderConstantF(constantIndex, mtx, 4);
} }
void Renderer::SetTexture( DWORD Stage, LPDIRECT3DBASETEXTURE9 pTexture )
{
if ( m_Textures[Stage] != pTexture )
{
m_Textures[Stage] = pTexture;
D3D::dev->SetTexture( Stage, pTexture );
}
}
void Renderer::SetFVF( DWORD FVF )
{
if ( m_FVF != FVF )
{
m_FVF = FVF;
D3D::dev->SetFVF( FVF );
}
}
void Renderer::SetRenderState( D3DRENDERSTATETYPE State, DWORD Value )
{
if ( m_RenderStates[State] != Value )
{
m_RenderStates[State] = Value;
D3D::dev->SetRenderState( State, Value );
}
}
void Renderer::SetTextureStageState( DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value )
{
if ( m_TextureStageStates[Stage][Type] != Value )
{
m_TextureStageStates[Stage][Type] = Value;
D3D::dev->SetTextureStageState( Stage, Type, Value );
}
}
void Renderer::SetSamplerState( DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value )
{
if ( m_SamplerStates[Sampler][Type] != Value )
{
m_SamplerStates[Sampler][Type] = Value;
D3D::dev->SetSamplerState( Sampler, Type, Value );
}
}
void Renderer::DrawPrimitiveUP( D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, const void* pVertexStreamZeroData, UINT VertexStreamZeroStride )
{
D3D::dev->DrawPrimitiveUP( PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride );
}
void Renderer::DrawPrimitive( D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount )
{
D3D::dev->DrawPrimitive( PrimitiveType, StartVertex, PrimitiveCount );
}

80
Source/Plugins/Plugin_VideoDX9/Src/Render.h
View File

@ -1,20 +1,35 @@
#pragma once #ifndef __H_RENDER__
#define __H_RENDER__
#include "PluginSpecs_Video.h" #include "PluginSpecs_Video.h"
#include <vector>
#include <string>
#include "D3DBase.h"
class Renderer class Renderer
{ {
// screen offset // screen offset
static float m_x,m_y,m_width, m_height,xScale,yScale; static float m_x,m_y,m_width, m_height,xScale,yScale;
const static int MaxTextureStages = 9;
const static int MaxRenderStates = 210;
const static DWORD MaxTextureTypes = 33;
const static DWORD MaxSamplerSize = 13;
const static DWORD MaxSamplerTypes = 15;
static std::vector<LPDIRECT3DBASETEXTURE9> m_Textures;
static DWORD m_RenderStates[MaxRenderStates];
static DWORD m_TextureStageStates[MaxTextureStages][MaxTextureTypes];
static DWORD m_SamplerStates[MaxSamplerSize][MaxSamplerTypes];
static DWORD m_FVF;
public: public:
static void Init(SVideoInitialize &_VideoInitialize); static void Init(SVideoInitialize &_VideoInitialize);
static void Shutdown(); static void Shutdown();
// initialize opengl standard values (like viewport) // initialize opengl standard values (like view port)
static void Initialize(void); static void Initialize(void);
// must be called if the windowsize has changed // must be called if the window size has changed
static void ReinitView(void); static void ReinitView(void);
// //
// --- Render Functions --- // --- Render Functions ---
@ -29,8 +44,63 @@ public:
static void SetProjection(float* _pProjection, int constantIndex = -1); static void SetProjection(float* _pProjection, int constantIndex = -1);
static void AddMessage(const char* pstr, unsigned int ms); static void AddMessage(const std::string &message, unsigned int ms);
static void ProcessMessages(); static void ProcessMessages();
static void RenderText(const char* pstr, int left, int top, unsigned int color); static void RenderText(const std::string &text, int left, int top, unsigned int color);
/**
* Assigns a texture to a device stage.
* @param Stage Stage to assign to.
* @param pTexture Texture to be assigned.
*/
static void SetTexture( DWORD Stage, IDirect3DBaseTexture9 *pTexture );
/**
* Sets the current vertex stream declaration.
* @param FVF Fixed function vertex type
*/
static void SetFVF( DWORD FVF );
/**
* Sets a single device render-state parameter.
* @param State Device state variable that is being modified.
* @param Value New value for the device render state to be set.
*/
static void SetRenderState( D3DRENDERSTATETYPE State, DWORD Value );
/**
* Sets the state value for the currently assigned texture.
* @param Stage Stage identifier of the texture for which the state value is set.
* @param Type Texture state to set.
* @param Value State value to set.
*/
static void SetTextureStageState( DWORD Stage, D3DTEXTURESTAGESTATETYPE Type,DWORD Value );
/**
* Sets the sampler state value.
* @param Sampler The sampler stage index.
* @param Type Type of the sampler.
* @param Value State value to set.
*/
static void SetSamplerState( DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value );
/**
* Renders data specified by a user memory pointer as a sequence of geometric primitives of the specified type.
* @param PrimitiveType Type of primitive to render.
* @param PrimitiveCount Number of primitives to render.
* @param pVertexStreamZeroData User memory pointer to the vertex data.
* @param VertexStreamZeroStride The number of bytes of data for each vertex.
*/
static void DrawPrimitiveUP( D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount,
const void* pVertexStreamZeroData, UINT VertexStreamZeroStride );
/**
* Renders a sequence of non indexed, geometric primitives of the specified type from the current set of data input streams.
* @param PrimitiveType Type of primitive to render.
* @param StartVertex Index of the first vertex to load.
* @param PrimitiveCount Number of primitives to render.
*/
static void DrawPrimitive( D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount );
}; };
#endif // __H_RENDER__

11
Source/Plugins/Plugin_VideoDX9/Src/TextureCache.cpp
View File

@ -117,7 +117,10 @@ void TextureCache::Load(int stage, DWORD address, int width, int height, int for
return; return;
} }
lastTexture[stage] = iter->second.texture; lastTexture[stage] = iter->second.texture;
D3D::dev->SetTexture(stage,iter->second.texture);
// D3D::dev->SetTexture(stage,iter->second.texture);
Renderer::SetTexture( stage, iter->second.texture );
return; return;
} }
else else
@ -182,7 +185,9 @@ void TextureCache::Load(int stage, DWORD address, int width, int height, int for
SETSTAT(stats.numTexturesAlive, (int)textures.size()); SETSTAT(stats.numTexturesAlive, (int)textures.size());
//Set the texture! //Set the texture!
D3D::dev->SetTexture(stage,entry.texture); // D3D::dev->SetTexture(stage,entry.texture);
Renderer::SetTexture( stage, entry.texture );
lastTexture[stage] = entry.texture; lastTexture[stage] = entry.texture;
} }
@ -219,4 +224,4 @@ void TextureCache::CopyEFBToRenderTarget(DWORD address, RECT *source)
srcSurface = D3D::GetBackBufferSurface(); srcSurface = D3D::GetBackBufferSurface();
D3D::dev->StretchRect(srcSurface,source,destSurface,0,D3DTEXF_NONE); D3D::dev->StretchRect(srcSurface,source,destSurface,0,D3DTEXF_NONE);
destSurface->Release(); destSurface->Release();
} }

2
Source/Plugins/Plugin_VideoDX9/Src/Utils.cpp
View File

@ -33,7 +33,7 @@ void InitLUTs()
} }
// Message handler for about box. // Message handler for about box.
LRESULT CALLBACK AboutProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) LRESULT CALLBACK AboutProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM /*lParam*/)
{ {
switch (message) switch (message)
{ {

2
Source/Plugins/Plugin_VideoDX9/Src/Utils.h
View File

@ -49,7 +49,7 @@ inline float Memory_Read_Float(u32 _uAddress)
extern int g_bWriteProfile; // global variable to enable/disable profiling (if DVPROFILE is defined) extern int g_bWriteProfile; // global variable to enable/disable profiling (if DVPROFILE is defined)
// IMPORTANT: For every Reigster there must be an End // IMPORTANT: For every Register there must be an End
void DVProfRegister(char* pname); // first checks if this profiler exists in g_listProfilers void DVProfRegister(char* pname); // first checks if this profiler exists in g_listProfilers
void DVProfEnd(u32 dwUserData); void DVProfEnd(u32 dwUserData);
void DVProfWrite(char* pfilename, u32 frames = 0); void DVProfWrite(char* pfilename, u32 frames = 0);

10
Source/Plugins/Plugin_VideoDX9/Src/VertexHandler.cpp
View File

@ -202,10 +202,12 @@ void CVertexHandler::Flush()
else else
{ {
D3D::dev->SetIndices(0); D3D::dev->SetIndices(0);
D3D::dev->DrawPrimitiveUP(D3DPT_POINTLIST,
numVertices, // D3D::dev->DrawPrimitiveUP(D3DPT_POINTLIST,
fakeVBuffer, // numVertices,
sizeof(D3DVertex)); // fakeVBuffer,
// sizeof(D3DVertex));
Renderer::DrawPrimitiveUP( D3DPT_POINTLIST, numVertices, fakeVBuffer, sizeof(D3DVertex) );
} }
} }
collection = C_NOTHING; collection = C_NOTHING;

25
Source/Plugins/Plugin_VideoDX9/Src/main.cpp
View File

@ -47,7 +47,7 @@ BOOL APIENTRY DllMain( HINSTANCE hinstDLL, // DLL module handle
BOOL Callback_PeekMessages() BOOL Callback_PeekMessages()
{ {
//TODO: peekmessage //TODO: peek message
MSG msg; MSG msg;
while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
{ {
@ -59,31 +59,34 @@ BOOL Callback_PeekMessages()
return TRUE; return TRUE;
} }
void UpdateFPSDisplay(const char *text) void UpdateFPSDisplay(const char *text)
{ {
char temp[512]; char temp[512];
sprintf(temp, "SVN R%i: %s", SVN_REV, text); sprintf_s(temp, 512, "SVN R%i: %s", SVN_REV, text);
SetWindowText(EmuWindow::GetWnd(), temp); SetWindowText( EmuWindow::GetWnd(), temp);
} }
bool Init() bool Init()
{ {
g_Config.Load(); g_Config.Load();
if (initCount==0) if (initCount == 0)
{ {
// create the window // create the window
if( !g_Config.renderToMainframe || g_VideoInitialize.pWindowHandle == NULL ) // ignore parent for this plugin if ( !g_Config.renderToMainframe || g_VideoInitialize.pWindowHandle == NULL ) // ignore parent for this plugin
{ {
g_VideoInitialize.pWindowHandle = (void*)EmuWindow::Create(NULL, g_hInstance, "Please wait..."); g_VideoInitialize.pWindowHandle = (void*)EmuWindow::Create(NULL, g_hInstance, "Loading - Please wait.");
} }
else else
{ {
g_VideoInitialize.pWindowHandle = (void*)EmuWindow::Create((HWND)g_VideoInitialize.pWindowHandle, g_hInstance, "Please wait..."); g_VideoInitialize.pWindowHandle = (void*)EmuWindow::Create((HWND)g_VideoInitialize.pWindowHandle, g_hInstance, "Loading - Please wait.");
} }
if( g_VideoInitialize.pWindowHandle == NULL ) { if ( g_VideoInitialize.pWindowHandle == NULL )
MessageBox(GetActiveWindow(), "failed to create window", "Fatal Error", MB_OK); {
MessageBox(GetActiveWindow(), "An error has occurred while trying to create the window.", "Fatal Error", MB_OK);
return false; return false;
} }
@ -93,7 +96,7 @@ bool Init()
if (FAILED(D3D::Init())) if (FAILED(D3D::Init()))
{ {
MessageBox(GetActiveWindow(), "Cant Init D3d.\nYou probably havn't installed\nthe last version(9.0c)", "Fatal Error", MB_OK); MessageBox(GetActiveWindow(), "Unable to initialize Direct3D. Please make sure that you have DirectX 9.0c correctly installed.", "Fatal Error", MB_OK);
return false; return false;
} }
InitLUTs(); InitLUTs();
@ -184,7 +187,7 @@ void Video_Shutdown(void)
DeInit(); DeInit();
} }
void Video_UpdateXFB(BYTE* _pXFB, DWORD _dwWidth, DWORD _dwHeight) void Video_UpdateXFB(BYTE* /*_pXFB*/, DWORD /*_dwWidth*/, DWORD /*_dwHeight*/)
{ {
/* /*
ConvertXFB(tempBuffer, _pXFB, _dwWidth, _dwHeight); ConvertXFB(tempBuffer, _pXFB, _dwWidth, _dwHeight);