Source/Plugins/Plugin_VideoDX9/Src/main.cpp

   1 // Copyright (C) 2003 Dolphin Project.
   2
   3 // This program is free software: you can redistribute it and/or modify
   4 // it under the terms of the GNU General Public License as published by
   5 // the Free Software Foundation, version 2.0.
   6
   7 // This program is distributed in the hope that it will be useful,
   8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10 // GNU General Public License 2.0 for more details.
  11
  12 // A copy of the GPL 2.0 should have been included with the program.
  13 // If not, see http://www.gnu.org/licenses/
  14
  15 // Official SVN repository and contact information can be found at
  16 // http://code.google.com/p/dolphin-emu/
  17
  18 #include "Common.h"
  19 #include "Atomic.h"
  20 #include "Thread.h"
  21 #include "LogManager.h"
  22 #include "debugger/debugger.h"
  23
  24 #if defined(HAVE_WX) && HAVE_WX
  25 #include "DlgSettings.h"
  26 GFXConfigDialogDX *m_ConfigFrame = NULL;
  27 #endif // HAVE_WX
  28
  29 #if defined(HAVE_WX) && HAVE_WX
  30 #include "Debugger/Debugger.h"
  31 #endif // HAVE_WX
  32
  33 #include "main.h"
  34 #include "VideoConfig.h"
  35 #include "Fifo.h"
  36 #include "OpcodeDecoding.h"
  37 #include "TextureCache.h"
  38 #include "BPStructs.h"
  39 #include "VertexManager.h"
  40 #include "VertexLoaderManager.h"
  41 #include "VertexShaderManager.h"
  42 #include "PixelShaderManager.h"
  43 #include "VertexShaderCache.h"
  44 #include "PixelShaderCache.h"
  45 #include "CommandProcessor.h"
  46 #include "PixelEngine.h"
  47 #include "OnScreenDisplay.h"
  48 #include "DlgSettings.h"
  49 #include "D3DTexture.h"
  50 #include "D3DUtil.h"
  51 #include "EmuWindow.h"
  52 #include "VideoState.h"
  53 #include "XFBConvert.h"
  54 #include "render.h"
  55
  56 HINSTANCE g_hInstance = NULL;
  57 SVideoInitialize g_VideoInitialize;
  58 PLUGIN_GLOBALS* globals = NULL;
  59 static bool s_PluginInitialized = false;
  60
  61 volatile u32 s_swapRequested = FALSE;
  62 static u32 s_efbAccessRequested = FALSE;
  63 static volatile u32 s_FifoShuttingDown = FALSE;
  64
  65 static volatile struct
  66 {
  67         u32 xfbAddr;
  68         FieldType field;
  69         u32 fbWidth;
  70         u32 fbHeight;
  71 } s_beginFieldArgs;
  72
  73 static volatile EFBAccessType s_AccessEFBType;
  74
  75 bool HandleDisplayList(u32 address, u32 size)
  76 {
  77         return false;
  78 }
  79
  80 bool IsD3D()
  81 {
  82         return true;
  83 }
  84
  85 // This is used for the functions right below here which use wxwidgets
  86 #if defined(HAVE_WX) && HAVE_WX
  87 WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
  88 #endif
  89
  90 void *DllDebugger(void *_hParent, bool Show)
  91 {
  92 #if defined(HAVE_WX) && HAVE_WX
  93         return new GFXDebuggerDX9((wxWindow *)_hParent);
  94 #else
  95         return NULL;
  96 #endif
  97 }
  98
  99 #if defined(HAVE_WX) && HAVE_WX
 100         class wxDLLApp : public wxApp
 101         {
 102                 bool OnInit()
 103                 {
 104                         return true;
 105                 }
 106         };
 107         IMPLEMENT_APP_NO_MAIN(wxDLLApp)
 108         WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
 109 #endif
 110
 111 BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD dwReason, LPVOID lpvReserved)
 112 {
 113         switch (dwReason)
 114         {
 115         case DLL_PROCESS_ATTACH:
 116                 {
 117 #if defined(HAVE_WX) && HAVE_WX
 118                         wxSetInstance((HINSTANCE)hinstDLL);
 119                         wxInitialize();
 120 #endif
 121                 }
 122                 break;
 123         case DLL_PROCESS_DETACH:
 124 #if defined(HAVE_WX) && HAVE_WX
 125                 wxUninitialize();
 126 #endif
 127                 break;
 128         }
 129
 130         g_hInstance = hinstDLL;
 131         return TRUE;
 132 }
 133
 134 unsigned int Callback_PeekMessages()
 135 {
 136         MSG msg;
 137         while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
 138         {
 139                 if (msg.message == WM_QUIT)
 140                         return FALSE;
 141                 TranslateMessage(&msg);
 142                 DispatchMessage(&msg);
 143         }
 144         return TRUE;
 145 }
 146
 147
 148 void UpdateFPSDisplay(const char *text)
 149 {
 150         TCHAR temp[512];
 151         swprintf_s(temp, 512, _T("SVN R%s: DX9: %hs"), svn_rev_str, text);
 152         SetWindowText(EmuWindow::GetWnd(), temp);
 153 }
 154
 155 void GetDllInfo (PLUGIN_INFO* _PluginInfo)
 156 {
 157         _PluginInfo->Version = 0x0100;
 158         _PluginInfo->Type = PLUGIN_TYPE_VIDEO;
 159 #ifdef DEBUGFAST
 160         sprintf_s(_PluginInfo->Name, 100, "Dolphin Direct3D9 (DebugFast)");
 161 #else
 162 #ifndef _DEBUG
 163         sprintf_s(_PluginInfo->Name, 100, "Dolphin Direct3D9");
 164 #else
 165         sprintf_s(_PluginInfo->Name, 100, "Dolphin Direct3D9 (Debug)");
 166 #endif
 167 #endif
 168 }
 169
 170 void SetDllGlobals(PLUGIN_GLOBALS* _pPluginGlobals)
 171 {
 172         globals = _pPluginGlobals;
 173         LogManager::SetInstance((LogManager*)globals->logManager);
 174 }
 175
 176 void DllAbout(HWND _hParent)
 177 {
 178         //DialogBox(g_hInstance,(LPCTSTR)IDD_ABOUT,_hParent,(DLGPROC)AboutProc);
 179 }
 180
 181 void DllConfig(void *_hParent)
 182 {
 183         // If not initialized, only init D3D so we can enumerate resolutions.
 184         if (!s_PluginInitialized)
 185                 D3D::Init();
 186         g_Config.Load((std::string(File::GetUserPath(D_CONFIG_IDX)) + "gfx_dx9.ini").c_str());
 187         g_Config.GameIniLoad(globals->game_ini);
 188         UpdateActiveConfig();
 189 #if defined(HAVE_WX) && HAVE_WX
 190         m_ConfigFrame = new GFXConfigDialogDX((wxWindow *)_hParent);
 191
 192         m_ConfigFrame->CreateGUIControls();
 193         m_ConfigFrame->ShowModal();
 194         m_ConfigFrame->Destroy();
 195 #endif
 196         if (!s_PluginInitialized)
 197                 D3D::Shutdown();
 198 }
 199
 200 void Initialize(void *init)
 201 {
 202         frameCount = 0;
 203         SVideoInitialize *_pVideoInitialize = (SVideoInitialize*)init;
 204         g_VideoInitialize = *_pVideoInitialize;
 205         InitXFBConvTables();
 206
 207         g_Config.Load((std::string(File::GetUserPath(D_CONFIG_IDX)) + "gfx_dx9.ini").c_str());
 208         g_Config.GameIniLoad(globals->game_ini);
 209         UpdateProjectionHack(g_Config.iPhackvalue);     // DX9 projection hack could be disabled by commenting out this line
 210         UpdateActiveConfig();
 211
 212         g_VideoInitialize.pWindowHandle = (void*)EmuWindow::Create((HWND)g_VideoInitialize.pWindowHandle, g_hInstance, _T("Loading - Please wait."));
 213         if (g_VideoInitialize.pWindowHandle == NULL)
 214         {
 215                 ERROR_LOG(VIDEO, "An error has occurred while trying to create the window.");
 216                 return;
 217         }
 218         else if (FAILED(D3D::Init()))
 219         {
 220                 MessageBox(GetActiveWindow(), _T("Unable to initialize Direct3D. Please make sure that you have the latest version of DirectX 9.0c correctly installed."), _T("Fatal Error"), MB_ICONERROR|MB_OK);
 221                 return;
 222         }
 223
 224         g_VideoInitialize.pPeekMessages = &Callback_PeekMessages;
 225         g_VideoInitialize.pUpdateFPSDisplay = &UpdateFPSDisplay;
 226
 227         _pVideoInitialize->pPeekMessages = g_VideoInitialize.pPeekMessages;
 228         _pVideoInitialize->pUpdateFPSDisplay = g_VideoInitialize.pUpdateFPSDisplay;
 229         _pVideoInitialize->pWindowHandle = g_VideoInitialize.pWindowHandle;
 230
 231         OSD::AddMessage("Dolphin Direct3D9 Video Plugin.", 5000);
 232         s_PluginInitialized = true;
 233 }
 234
 235 void Video_Prepare()
 236 {
 237         // Better be safe...
 238         s_efbAccessRequested = FALSE;
 239         s_FifoShuttingDown = FALSE;
 240         s_swapRequested = FALSE;
 241         Renderer::Init();
 242         TextureCache::Init();
 243         BPInit();
 244         VertexManager::Init();
 245         Fifo_Init();
 246         VertexLoaderManager::Init();
 247         OpcodeDecoder_Init();
 248         VertexShaderManager::Init();
 249         PixelShaderManager::Init();
 250         CommandProcessor::Init();
 251         PixelEngine::Init();
 252
 253         // Tell the host the window is ready
 254         g_VideoInitialize.pCoreMessage(WM_USER_CREATE);
 255 }
 256
 257 void Shutdown()
 258 {
 259         s_efbAccessRequested = FALSE;
 260         s_FifoShuttingDown = FALSE;
 261         s_swapRequested = FALSE;
 262         Fifo_Shutdown();
 263         CommandProcessor::Shutdown();
 264         VertexManager::Shutdown();
 265         VertexLoaderManager::Shutdown();
 266         VertexShaderManager::Shutdown();
 267         PixelShaderManager::Shutdown();
 268         TextureCache::Shutdown();
 269         OpcodeDecoder_Shutdown();
 270         Renderer::Shutdown();
 271         D3D::Shutdown();
 272         EmuWindow::Close();
 273         s_PluginInitialized = false;
 274 }
 275
 276 void DoState(unsigned char **ptr, int mode) {
 277         // Clear texture cache because it might have written to RAM
 278         CommandProcessor::FifoCriticalEnter();
 279         TextureCache::Invalidate(false);
 280         CommandProcessor::FifoCriticalLeave();
 281         // No need to clear shader caches.
 282         PointerWrap p(ptr, mode);
 283         VideoCommon_DoState(p);
 284 }
 285
 286 void EmuStateChange(PLUGIN_EMUSTATE newState)
 287 {
 288         Fifo_RunLoop((newState == PLUGIN_EMUSTATE_PLAY) ? true : false);
 289 }
 290
 291 void Video_EnterLoop()
 292 {
 293         Fifo_EnterLoop(g_VideoInitialize);
 294 }
 295
 296 void Video_ExitLoop()
 297 {
 298         Fifo_ExitLoop();
 299
 300         s_FifoShuttingDown = TRUE;
 301 }
 302
 303 void Video_SetRendering(bool bEnabled) {
 304         Fifo_SetRendering(bEnabled);
 305 }
 306
 307 // Run from the graphics thread (from Fifo.cpp)
 308 void VideoFifo_CheckSwapRequest()
 309 {
 310         if(g_ActiveConfig.bUseXFB)
 311         {
 312                 if (Common::AtomicLoadAcquire(s_swapRequested))
 313                 {
 314                         EFBRectangle rc;
 315                         Renderer::Swap(s_beginFieldArgs.xfbAddr, s_beginFieldArgs.field, s_beginFieldArgs.fbWidth, s_beginFieldArgs.fbHeight,rc);
 316                         Common::AtomicStoreRelease(s_swapRequested, FALSE);
 317                 }
 318         }
 319 }
 320
 321 inline bool addrRangesOverlap(u32 aLower, u32 aUpper, u32 bLower, u32 bUpper)
 322 {
 323         return !((aLower >= bUpper) || (bLower >= aUpper));
 324 }
 325
 326 // Run from the graphics thread (from Fifo.cpp)
 327 void VideoFifo_CheckSwapRequestAt(u32 xfbAddr, u32 fbWidth, u32 fbHeight)
 328 {
 329         if (g_ActiveConfig.bUseXFB)
 330         {
 331                 if(Common::AtomicLoadAcquire(s_swapRequested))
 332                 {
 333                         u32 aLower = xfbAddr;
 334                         u32 aUpper = xfbAddr + 2 * fbWidth * fbHeight;
 335                         u32 bLower = s_beginFieldArgs.xfbAddr;
 336                         u32 bUpper = s_beginFieldArgs.xfbAddr + 2 * s_beginFieldArgs.fbWidth * s_beginFieldArgs.fbHeight;
 337
 338                         if (addrRangesOverlap(aLower, aUpper, bLower, bUpper))
 339                                 VideoFifo_CheckSwapRequest();
 340                 }
 341         }
 342 }
 343
 344 // Run from the CPU thread (from VideoInterface.cpp)
 345 void Video_BeginField(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight)
 346 {
 347         if (s_PluginInitialized && g_ActiveConfig.bUseXFB)
 348         {
 349                 if (g_VideoInitialize.bOnThread)
 350                 {
 351                         while (Common::AtomicLoadAcquire(s_swapRequested) && !s_FifoShuttingDown)
 352                                 //Common::SleepCurrentThread(1);
 353                                 Common::YieldCPU();
 354                 }
 355                 else
 356                         VideoFifo_CheckSwapRequest();
 357                 s_beginFieldArgs.xfbAddr = xfbAddr;
 358                 s_beginFieldArgs.field = field;
 359                 s_beginFieldArgs.fbWidth = fbWidth;
 360                 s_beginFieldArgs.fbHeight = fbHeight;
 361
 362                 Common::AtomicStoreRelease(s_swapRequested, TRUE);
 363         }
 364 }
 365
 366 void Video_EndField()
 367 {
 368 }
 369
 370 void Video_AddMessage(const char* pstr, u32 milliseconds)
 371 {
 372         OSD::AddMessage(pstr,milliseconds);
 373 }
 374
 375 HRESULT ScreenShot(const char *File)
 376 {
 377         Renderer::SetScreenshot(File);
 378         return S_OK;
 379 }
 380
 381 void Video_Screenshot(const char *_szFilename)
 382 {
 383         if (ScreenShot(_szFilename) != S_OK)
 384                 PanicAlert("Error while capturing screen");
 385         else {
 386                 std::string message =  "Saved ";
 387                 message += _szFilename;
 388                 OSD::AddMessage(message.c_str(), 2000);
 389         }
 390 }
 391
 392 static struct
 393 {
 394         EFBAccessType type;
 395         u32 x;
 396         u32 y;
 397         u32 Data;
 398 } s_accessEFBArgs;
 399
 400 static u32 s_AccessEFBResult = 0;
 401
 402 void VideoFifo_CheckEFBAccess()
 403 {
 404         if (Common::AtomicLoadAcquire(s_efbAccessRequested))
 405         {
 406                 s_AccessEFBResult = Renderer::AccessEFB(s_accessEFBArgs.type, s_accessEFBArgs.x, s_accessEFBArgs.y);
 407
 408                 Common::AtomicStoreRelease(s_efbAccessRequested, FALSE);
 409         }
 410 }
 411
 412 u32 Video_AccessEFB(EFBAccessType type, u32 x, u32 y,u32 InputData)
 413 {
 414         if (s_PluginInitialized)
 415         {
 416                 s_accessEFBArgs.type = type;
 417                 s_accessEFBArgs.x = x;
 418                 s_accessEFBArgs.y = y;
 419                 s_accessEFBArgs.Data = InputData;
 420
 421                 Common::AtomicStoreRelease(s_efbAccessRequested, TRUE);
 422
 423                 if (g_VideoInitialize.bOnThread)
 424                 {
 425                         while (Common::AtomicLoadAcquire(s_efbAccessRequested) && !s_FifoShuttingDown)
 426                                 //Common::SleepCurrentThread(1);
 427                                 Common::YieldCPU();
 428                 }
 429                 else
 430                         VideoFifo_CheckEFBAccess();
 431
 432                 return s_AccessEFBResult;
 433         }
 434
 435         return 0;
 436 }
 437
 438
 439 void Video_CommandProcessorRead16(u16& _rReturnValue, const u32 _Address)
 440 {
 441         CommandProcessor::Read16(_rReturnValue, _Address);
 442 }
 443
 444 void Video_CommandProcessorWrite16(const u16 _Data, const u32 _Address)
 445 {
 446         CommandProcessor::Write16(_Data, _Address);
 447 }
 448
 449 void Video_PixelEngineRead16(u16& _rReturnValue, const u32 _Address)
 450 {
 451         PixelEngine::Read16(_rReturnValue, _Address);
 452 }
 453
 454 void Video_PixelEngineWrite16(const u16 _Data, const u32 _Address)
 455 {
 456         PixelEngine::Write16(_Data, _Address);
 457 }
 458
 459 void Video_PixelEngineWrite32(const u32 _Data, const u32 _Address)
 460 {
 461         PixelEngine::Write32(_Data, _Address);
 462 }
 463
 464 inline void Video_GatherPipeBursted(void)
 465 {
 466         CommandProcessor::GatherPipeBursted();
 467 }
 468
 469 void Video_WaitForFrameFinish(void)
 470 {
 471         CommandProcessor::WaitForFrameFinish();
 472 }
 473
 474 bool Video_IsFifoBusy(void)
 475 {
 476         return CommandProcessor::isFifoBusy;
 477 }