Source/Plugins/Plugin_VideoDX9/Src/Render.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 <list>
  19 #include <d3dx9.h>
  20 #include <strsafe.h>
  21
  22 #include "StringUtil.h"
  23 #include "Common.h"
  24 #include "Atomic.h"
  25 #include "FileUtil.h"
  26 #include "Thread.h"
  27 #include "Timer.h"
  28 #include "Statistics.h"
  29
  30 #include "VideoConfig.h"
  31 #include "main.h"
  32 #include "VertexManager.h"
  33 #include "Render.h"
  34 #include "OpcodeDecoding.h"
  35 #include "BPStructs.h"
  36 #include "XFStructs.h"
  37 #include "D3DUtil.h"
  38 #include "VertexShaderManager.h"
  39 #include "PixelShaderManager.h"
  40 #include "VertexShaderCache.h"
  41 #include "PixelShaderCache.h"
  42 #include "VertexLoaderManager.h"
  43 #include "TextureCache.h"
  44 #include "EmuWindow.h"
  45 #include "AVIDump.h"
  46 #include "OnScreenDisplay.h"
  47 #include "FramebufferManager.h"
  48 #include "Fifo.h"
  49 #include "TextureConverter.h"
  50
  51 #include "debugger/debugger.h"
  52
  53 int s_fps=0;
  54
  55 static bool WindowResized;
  56 static int s_target_width;
  57 static int s_target_height;
  58
  59 static int s_Fulltarget_width;
  60 static int s_Fulltarget_height;
  61
  62 static int s_backbuffer_width;
  63 static int s_backbuffer_height;
  64
  65 static int s_XFB_width;
  66 static int s_XFB_height;
  67
  68 static float xScale;
  69 static float yScale;
  70
  71 static float EFBxScale;
  72 static float EFByScale;
  73
  74 static int s_recordWidth;
  75 static int s_recordHeight;
  76
  77 static bool s_LastFrameDumped;
  78 static bool s_AVIDumping;
  79
  80 static u32 s_blendMode;
  81 static u32 s_LastAA;
  82 static u32 s_LastEFBScale;
  83 static bool IS_AMD;
  84 static bool XFBWrited;
  85
  86 // used extern by other files. need to clean this up at some point.
  87 int frameCount;
  88
  89 static char *st;
  90
  91 static bool s_bScreenshot = false;
  92 static Common::CriticalSection s_criticalScreenshot;
  93 static char s_sScreenshotName[1024];
  94 static LPDIRECT3DSURFACE9 ScreenShootMEMSurface = NULL;
  95
  96
  97 // State translation lookup tables
  98 static const D3DBLEND d3dSrcFactors[8] =
  99 {
 100         D3DBLEND_ZERO,
 101         D3DBLEND_ONE,
 102         D3DBLEND_DESTCOLOR,
 103         D3DBLEND_INVDESTCOLOR,
 104         D3DBLEND_SRCALPHA,
 105         D3DBLEND_INVSRCALPHA,
 106         D3DBLEND_DESTALPHA,
 107         D3DBLEND_INVDESTALPHA
 108 };
 109
 110 static const D3DBLEND d3dDestFactors[8] =
 111 {
 112         D3DBLEND_ZERO,
 113         D3DBLEND_ONE,
 114         D3DBLEND_SRCCOLOR,
 115         D3DBLEND_INVSRCCOLOR,
 116         D3DBLEND_SRCALPHA,
 117         D3DBLEND_INVSRCALPHA,
 118         D3DBLEND_DESTALPHA,
 119         D3DBLEND_INVDESTALPHA
 120 };
 121
 122 static const D3DBLENDOP d3dLogicOpop[16] =
 123 {
 124         D3DBLENDOP_ADD,
 125         D3DBLENDOP_ADD,
 126         D3DBLENDOP_SUBTRACT,
 127         D3DBLENDOP_ADD,
 128         D3DBLENDOP_REVSUBTRACT,
 129         D3DBLENDOP_ADD,
 130         D3DBLENDOP_MAX,
 131         D3DBLENDOP_ADD,
 132
 133         D3DBLENDOP_MAX,
 134         D3DBLENDOP_MAX,
 135         D3DBLENDOP_ADD,
 136         D3DBLENDOP_ADD,
 137         D3DBLENDOP_ADD,
 138         D3DBLENDOP_ADD,
 139         D3DBLENDOP_ADD,
 140         D3DBLENDOP_ADD
 141 };
 142
 143 static const D3DBLEND d3dLogicOpSrcFactors[16] =
 144 {
 145         D3DBLEND_ZERO,
 146         D3DBLEND_DESTCOLOR,
 147         D3DBLEND_ONE,
 148         D3DBLEND_ONE,
 149         D3DBLEND_DESTCOLOR,
 150         D3DBLEND_ZERO,
 151         D3DBLEND_INVDESTCOLOR,
 152         D3DBLEND_INVDESTCOLOR,
 153
 154         D3DBLEND_INVSRCCOLOR,
 155         D3DBLEND_INVSRCCOLOR,
 156         D3DBLEND_INVDESTCOLOR,
 157         D3DBLEND_ONE,
 158         D3DBLEND_INVSRCCOLOR,
 159         D3DBLEND_INVSRCCOLOR,
 160         D3DBLEND_INVDESTCOLOR,
 161         D3DBLEND_ONE
 162 };
 163
 164 static const D3DBLEND d3dLogicOpDestFactors[16] =
 165 {
 166         D3DBLEND_ZERO,
 167         D3DBLEND_ZERO,
 168         D3DBLEND_INVSRCCOLOR,
 169         D3DBLEND_ZERO,
 170         D3DBLEND_ONE,
 171         D3DBLEND_ONE,
 172         D3DBLEND_INVSRCCOLOR,
 173         D3DBLEND_ONE,
 174
 175         D3DBLEND_INVDESTCOLOR,
 176         D3DBLEND_SRCCOLOR,
 177         D3DBLEND_INVDESTCOLOR,
 178         D3DBLEND_INVDESTCOLOR,
 179         D3DBLEND_INVSRCCOLOR,
 180         D3DBLEND_ONE,
 181         D3DBLEND_INVSRCCOLOR,
 182         D3DBLEND_ONE
 183 };
 184
 185 static const D3DCULL d3dCullModes[4] =
 186 {
 187         D3DCULL_NONE,
 188         D3DCULL_CCW,
 189         D3DCULL_CW,
 190         D3DCULL_CCW
 191 };
 192
 193 static const D3DCMPFUNC d3dCmpFuncs[8] =
 194 {
 195         D3DCMP_NEVER,
 196         D3DCMP_LESS,
 197         D3DCMP_EQUAL,
 198         D3DCMP_LESSEQUAL,
 199         D3DCMP_GREATER,
 200         D3DCMP_NOTEQUAL,
 201         D3DCMP_GREATEREQUAL,
 202         D3DCMP_ALWAYS
 203 };
 204
 205 static const D3DTEXTUREFILTERTYPE d3dMipFilters[4] =
 206 {
 207         D3DTEXF_NONE,
 208         D3DTEXF_POINT,
 209         D3DTEXF_LINEAR,
 210         D3DTEXF_NONE, //reserved
 211 };
 212
 213 static const D3DTEXTUREADDRESS d3dClamps[4] =
 214 {
 215         D3DTADDRESS_CLAMP,
 216         D3DTADDRESS_WRAP,
 217         D3DTADDRESS_MIRROR,
 218         D3DTADDRESS_WRAP //reserved
 219 };
 220
 221 void SetupDeviceObjects()
 222 {
 223         D3D::font.Init();
 224         VertexLoaderManager::Init();
 225         FBManager.Create();
 226
 227         VertexShaderManager::Dirty();
 228         PixelShaderManager::Dirty();
 229         TextureConverter::Init();
 230
 231         // To avoid shader compilation stutters, read back all shaders from cache.
 232         VertexShaderCache::Init();
 233         PixelShaderCache::Init();
 234         // Texture cache will recreate themselves over time.
 235 }
 236
 237 // Kill off all POOL_DEFAULT device objects.
 238 void TeardownDeviceObjects()
 239 {
 240         if(ScreenShootMEMSurface)
 241                 ScreenShootMEMSurface->Release();
 242         ScreenShootMEMSurface = NULL;
 243         D3D::dev->SetRenderTarget(0, D3D::GetBackBufferSurface());
 244         D3D::dev->SetDepthStencilSurface(D3D::GetBackBufferDepthSurface());
 245         FBManager.Destroy();
 246         D3D::font.Shutdown();
 247         TextureCache::Invalidate(false);
 248         VertexLoaderManager::Shutdown();
 249         VertexShaderCache::Shutdown();
 250         PixelShaderCache::Shutdown();
 251         TextureConverter::Shutdown();
 252 }
 253
 254 bool Renderer::Init()
 255 {
 256         st = new char[32768];
 257         UpdateActiveConfig();
 258         int fullScreenRes, x, y, w_temp, h_temp;
 259         s_blendMode = 0;
 260         // Multisample Anti-aliasing hasn't been implemented yet use supersamling instead
 261         int backbuffer_ms_mode = 0;
 262
 263         g_VideoInitialize.pRequestWindowSize(x, y, w_temp, h_temp);
 264
 265         for (fullScreenRes = 0; fullScreenRes < (int)D3D::GetAdapter(g_ActiveConfig.iAdapter).resolutions.size(); fullScreenRes++)
 266         {
 267                 if ((D3D::GetAdapter(g_ActiveConfig.iAdapter).resolutions[fullScreenRes].xres == w_temp) &&
 268                         (D3D::GetAdapter(g_ActiveConfig.iAdapter).resolutions[fullScreenRes].yres == h_temp))
 269                         break;
 270         }
 271         if (fullScreenRes == D3D::GetAdapter(g_ActiveConfig.iAdapter).resolutions.size())
 272                 fullScreenRes = 0;
 273
 274         D3D::Create(g_ActiveConfig.iAdapter, EmuWindow::GetWnd(),
 275                                 fullScreenRes, backbuffer_ms_mode, false);
 276
 277         IS_AMD = D3D::IsATIDevice();
 278         s_backbuffer_width = D3D::GetBackBufferWidth();
 279         s_backbuffer_height = D3D::GetBackBufferHeight();
 280
 281         s_XFB_width = MAX_XFB_WIDTH;
 282         s_XFB_height = MAX_XFB_HEIGHT;
 283
 284         TargetRectangle dst_rect;
 285         ComputeDrawRectangle(s_backbuffer_width, s_backbuffer_height, false, &dst_rect);
 286
 287         if(g_ActiveConfig.bUseRealXFB)
 288         {
 289                 xScale = yScale = 1.0f;
 290         }
 291         else
 292         {
 293                 xScale = (float)(dst_rect.right - dst_rect.left) / (float)s_XFB_width;
 294                 yScale = (float)(dst_rect.bottom - dst_rect.top) / (float)s_XFB_height;
 295         }
 296
 297         s_LastAA = g_ActiveConfig.iMultisampleMode;
 298         s_LastEFBScale = g_ActiveConfig.iEFBScale;
 299         float SupersampleCoeficient = s_LastAA + 1;
 300         switch(s_LastEFBScale)
 301         {
 302                 case 0:
 303                         EFBxScale = xScale;
 304                         EFByScale = yScale;
 305                         break;
 306                 case 1:
 307                         EFBxScale = ceilf(xScale);
 308                         EFByScale = ceilf(yScale);
 309                         break;
 310                 default:
 311                         EFBxScale = g_ActiveConfig.iEFBScale - 1;
 312                         EFByScale = EFBxScale;
 313                         break;
 314         };
 315
 316         EFBxScale *= SupersampleCoeficient;
 317         EFByScale *= SupersampleCoeficient;
 318
 319         s_target_width  = EFB_WIDTH * EFBxScale;
 320         s_target_height = EFB_HEIGHT * EFByScale;
 321
 322         s_Fulltarget_width  = s_target_width;
 323         s_Fulltarget_height = s_target_height;
 324
 325         s_LastFrameDumped = false;
 326         s_AVIDumping = false;
 327
 328         // We're not using fixed function.
 329         // Let's just set the matrices to identity to be sure.
 330         D3DXMATRIX mtx;
 331         D3DXMatrixIdentity(&mtx);
 332         D3D::dev->SetTransform(D3DTS_VIEW, &mtx);
 333         D3D::dev->SetTransform(D3DTS_WORLD, &mtx);
 334
 335         SetupDeviceObjects();
 336
 337         for (int stage = 0; stage < 8; stage++)
 338                 D3D::SetSamplerState(stage, D3DSAMP_MAXANISOTROPY, g_ActiveConfig.iMaxAnisotropy);
 339
 340         D3DVIEWPORT9 vp;
 341         vp.X = 0;
 342         vp.Y = 0;
 343         vp.Width  = s_backbuffer_width;
 344         vp.Height = s_backbuffer_height;
 345         vp.MinZ = 0.0f;
 346         vp.MaxZ = 1.0f;
 347         D3D::dev->SetViewport(&vp);
 348         D3D::dev->Clear(0, NULL, D3DCLEAR_TARGET, 0x0, 0, 0);
 349
 350         D3D::dev->SetRenderTarget(0, FBManager.GetEFBColorRTSurface());
 351         D3D::dev->SetDepthStencilSurface(FBManager.GetEFBDepthRTSurface());
 352         vp.X = (s_Fulltarget_width - s_target_width) / 2;
 353         vp.Y = (s_Fulltarget_height - s_target_height) / 2;
 354         vp.Width  = s_target_width;
 355         vp.Height = s_target_height;
 356         D3D::dev->SetViewport(&vp);
 357         D3D::dev->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x0, 1.0f, 0);
 358         D3D::BeginFrame();
 359         D3D::SetRenderState(D3DRS_SCISSORTESTENABLE, true);
 360         D3D::dev->CreateOffscreenPlainSurface(s_backbuffer_width,s_backbuffer_height, D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &ScreenShootMEMSurface, NULL );
 361         return true;
 362 }
 363
 364 void Renderer::Shutdown()
 365 {
 366         TeardownDeviceObjects();
 367         D3D::EndFrame();
 368         D3D::Present();
 369         D3D::Close();
 370
 371         if (s_AVIDumping)
 372         {
 373                 AVIDump::Stop();
 374         }
 375         delete [] st;
 376 }
 377
 378 int Renderer::GetTargetWidth() { return s_target_width; }
 379 int Renderer::GetTargetHeight() { return s_target_height; }
 380 int Renderer::GetFullTargetWidth() { return s_Fulltarget_width; }
 381 int Renderer::GetFullTargetHeight() { return s_Fulltarget_height; }
 382 float Renderer::GetTargetScaleX() { return EFBxScale; }
 383 float Renderer::GetTargetScaleY() { return EFByScale; }
 384
 385 float Renderer::GetXFBScaleX() { return xScale; }
 386 float Renderer::GetXFBScaleY() { return yScale; }
 387
 388
 389 int Renderer::GetFrameBufferWidth()
 390 {
 391         return s_backbuffer_width;
 392 }
 393 int Renderer::GetFrameBufferHeight()
 394 {
 395         return s_backbuffer_height;
 396 }
 397
 398 // Create On-Screen-Messages
 399 void Renderer::DrawDebugText()
 400 {
 401         // OSD Menu messages
 402         if (g_ActiveConfig.bOSDHotKey)
 403         {
 404                 if (OSDChoice > 0)
 405                 {
 406                         OSDTime = Common::Timer::GetTimeMs() + 3000;
 407                         OSDChoice = -OSDChoice;
 408                 }
 409                 if ((u32)OSDTime > Common::Timer::GetTimeMs())
 410                 {
 411                         std::string T1 = "", T2 = "";
 412                         std::vector<std::string> T0;
 413
 414                         std::string OSDM1 = StringFromFormat("%i x %i", OSDInternalW, OSDInternalH);
 415                         std::string OSDM21;
 416                         switch(g_ActiveConfig.iAspectRatio)
 417                         {
 418                         case ASPECT_AUTO:
 419                                 OSDM21 = "Auto";
 420                                 break;
 421                         case ASPECT_FORCE_16_9:
 422                                 OSDM21 = "16:9";
 423                                 break;
 424                         case ASPECT_FORCE_4_3:
 425                                 OSDM21 = "4:3";
 426                                 break;
 427                         case ASPECT_STRETCH:
 428                                 OSDM21 = "Stretch";
 429                                 break;
 430                         }
 431                         std::string OSDM22 =
 432                                 g_ActiveConfig.bCrop ? " (crop)" : "";
 433                         std::string OSDM3 = g_ActiveConfig.bEFBCopyDisable ? "Disabled" :
 434                                 g_ActiveConfig.bCopyEFBToTexture ? "To Texture" : "To RAM";
 435
 436                         // If there is more text than this we will have a collission
 437                         if (g_ActiveConfig.bShowFPS)
 438                                 { T1 += "\n\n"; T2 += "\n\n"; }
 439
 440                         // The rows
 441                         T0.push_back(StringFromFormat("3: Internal Resolution: %s\n", OSDM1.c_str()));
 442                         T0.push_back(StringFromFormat("4: Aspect Ratio: %s%s\n", OSDM21.c_str(), OSDM22.c_str()));
 443                         T0.push_back(StringFromFormat("5: Copy EFB: %s\n", OSDM3.c_str()));
 444                         T0.push_back(StringFromFormat("6: Fog: %s\n", g_ActiveConfig.bDisableFog ? "Disabled" : "Enabled"));
 445                         T0.push_back(StringFromFormat("7: Material Lighting: %s\n", g_ActiveConfig.bDisableLighting ? "Disabled" : "Enabled"));
 446
 447                         // The latest changed setting in yellow
 448                         T1 += (OSDChoice == -1) ? T0.at(0) : "\n";
 449                         T1 += (OSDChoice == -2) ? T0.at(1) : "\n";
 450                         T1 += (OSDChoice == -3) ? T0.at(2) : "\n";
 451                         T1 += (OSDChoice == -4) ? T0.at(3) : "\n";
 452                         T1 += (OSDChoice == -5) ? T0.at(4) : "\n";
 453
 454                         // The other settings in cyan
 455                         T2 += (OSDChoice != -1) ? T0.at(0) : "\n";
 456                         T2 += (OSDChoice != -2) ? T0.at(1) : "\n";
 457                         T2 += (OSDChoice != -3) ? T0.at(2) : "\n";
 458                         T2 += (OSDChoice != -4) ? T0.at(3) : "\n";
 459                         T2 += (OSDChoice != -5) ? T0.at(4) : "\n";
 460
 461                         // Render a shadow, and then the text
 462                         Renderer::RenderText(T1.c_str(), 21, 21, 0xDD000000);
 463                         Renderer::RenderText(T1.c_str(), 20, 20, 0xFFffff00);
 464                         Renderer::RenderText(T2.c_str(), 21, 21, 0xDD000000);
 465                         Renderer::RenderText(T2.c_str(), 20, 20, 0xFF00FFFF);
 466                 }
 467         }
 468 }
 469
 470 void Renderer::RenderText(const char *text, int left, int top, u32 color)
 471 {
 472         D3D::font.DrawTextScaled((float)left, (float)top, 20, 20, 0.0f, color, text, false);
 473 }
 474
 475 TargetRectangle Renderer::ConvertEFBRectangle(const EFBRectangle& rc)
 476 {
 477         int Xstride = (s_Fulltarget_width - s_target_width) / 2;
 478         int Ystride = (s_Fulltarget_height - s_target_height) / 2;
 479         TargetRectangle result;
 480         result.left   = (int)(rc.left   * EFBxScale) + Xstride;
 481         result.top    = (int)(rc.top    * EFByScale) + Ystride;
 482         result.right  = (int)(rc.right  * EFBxScale) + Xstride;
 483         result.bottom = (int)(rc.bottom * EFByScale) + Ystride;
 484         return result;
 485 }
 486
 487 void formatBufferDump(const char *in, char *out, int w, int h, int p)
 488 {
 489         for (int y = 0; y < h; y++)
 490         {
 491                 const char *line = in + (h - y - 1) * p;
 492                 for (int x = 0; x < w; x++)
 493                 {
 494                         memcpy(out, line, 3);
 495                         out += 3;
 496                         line += 4;
 497                 }
 498         }
 499 }
 500
 501 // With D3D, we have to resize the backbuffer if the window changed
 502 // size.
 503 void CheckForResize()
 504 {
 505         while (EmuWindow::IsSizing())
 506         {
 507                 Sleep(10);
 508         }
 509
 510         if (EmuWindow::GetParentWnd())
 511         {
 512                 // Re-stretch window to parent window size again, if it has a parent window.
 513                 RECT rcParentWindow;
 514                 GetWindowRect(EmuWindow::GetParentWnd(), &rcParentWindow);
 515                 int width = rcParentWindow.right - rcParentWindow.left;
 516                 int height = rcParentWindow.bottom - rcParentWindow.top;
 517                 if (width != s_backbuffer_width || height != s_backbuffer_height)
 518                         MoveWindow(EmuWindow::GetWnd(), 0, 0, width, height, FALSE);
 519         }
 520         RECT rcWindow;
 521         GetClientRect(EmuWindow::GetWnd(), &rcWindow);
 522         int client_width = rcWindow.right - rcWindow.left;
 523         int client_height = rcWindow.bottom - rcWindow.top;
 524         // Sanity check.
 525         if ((client_width != s_backbuffer_width ||
 526                 client_height != s_backbuffer_height) &&
 527                 client_width >= 4 && client_height >= 4)
 528         {
 529                 TeardownDeviceObjects();
 530
 531                 D3D::Reset();
 532                 s_backbuffer_width = D3D::GetBackBufferWidth();
 533                 s_backbuffer_height = D3D::GetBackBufferHeight();
 534                 if(ScreenShootMEMSurface)
 535                         ScreenShootMEMSurface->Release();
 536                 D3D::dev->CreateOffscreenPlainSurface(s_backbuffer_width,s_backbuffer_height, D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &ScreenShootMEMSurface, NULL );
 537                 WindowResized = true;
 538         }
 539 }
 540
 541
 542
 543 void Renderer::RenderToXFB(u32 xfbAddr, u32 fbWidth, u32 fbHeight, const EFBRectangle& sourceRc)
 544 {
 545         if (!fbWidth || !fbHeight)
 546                 return;
 547         VideoFifo_CheckEFBAccess();
 548         VideoFifo_CheckSwapRequestAt(xfbAddr, fbWidth, fbHeight);
 549         XFBWrited = true;
 550         // XXX: Without the VI, how would we know what kind of field this is? So
 551         // just use progressive.
 552         if (g_ActiveConfig.bUseXFB)
 553         {
 554                 FBManager.CopyToXFB(xfbAddr, fbWidth, fbHeight, sourceRc);
 555         }
 556         else
 557         {
 558                 Renderer::Swap(xfbAddr, FIELD_PROGRESSIVE, fbWidth, fbHeight,sourceRc);
 559                 Common::AtomicStoreRelease(s_swapRequested, FALSE);
 560         }
 561 }
 562
 563 bool Renderer::SetScissorRect()
 564 {
 565         int xoff = bpmem.scissorOffset.x * 2 - 342;
 566         int yoff = bpmem.scissorOffset.y * 2 - 342;
 567         RECT rc;
 568         rc.left   = (int)((float)bpmem.scissorTL.x - xoff - 342);
 569         rc.top    = (int)((float)bpmem.scissorTL.y - yoff - 342);
 570         rc.right  = (int)((float)bpmem.scissorBR.x - xoff - 341);
 571         rc.bottom = (int)((float)bpmem.scissorBR.y - yoff - 341);
 572
 573         if (rc.left < 0) rc.left = 0;
 574         if (rc.right < 0) rc.right = 0;
 575         if (rc.left > EFB_WIDTH) rc.left = EFB_WIDTH;
 576         if (rc.right > EFB_WIDTH) rc.right = EFB_WIDTH;
 577         if (rc.top < 0) rc.top = 0;
 578         if (rc.bottom < 0) rc.bottom = 0;
 579         if (rc.top > EFB_HEIGHT) rc.top = EFB_HEIGHT;
 580         if (rc.bottom > EFB_HEIGHT) rc.bottom = EFB_HEIGHT;
 581
 582         if (rc.left > rc.right)
 583         {
 584                 int temp = rc.right;
 585                 rc.right = rc.left;
 586                 rc.left = temp;
 587         }
 588         if (rc.top > rc.bottom)
 589         {
 590                 int temp = rc.bottom;
 591                 rc.bottom = rc.top;
 592                 rc.top = temp;
 593         }
 594
 595         int Xstride =  (s_Fulltarget_width - s_target_width) / 2;
 596         int Ystride =  (s_Fulltarget_height - s_target_height) / 2;
 597
 598         rc.left   = (int)(rc.left   * EFBxScale) + Xstride;
 599         rc.top    = (int)(rc.top    * EFByScale) + Ystride;
 600         rc.right  = (int)(rc.right  * EFBxScale) + Xstride;
 601         rc.bottom = (int)(rc.bottom * EFByScale) + Ystride;
 602
 603         if (rc.right != rc.left && rc.bottom != rc.top)
 604         {
 605                 D3D::dev->SetScissorRect(&rc);
 606                 return true;
 607         }
 608         else
 609         {
 610                 //WARN_LOG(VIDEO, "Bad scissor rectangle: %i %i %i %i", rc.left, rc.top, rc.right, rc.bottom);
 611                 rc.left   = Xstride;
 612                 rc.top    = Ystride;
 613                 rc.right  = Xstride + s_target_width;
 614                 rc.bottom = Ystride + s_target_height;
 615                 D3D::dev->SetScissorRect(&rc);
 616         }
 617         return false;
 618 }
 619
 620 void Renderer::SetColorMask()
 621 {
 622         DWORD color_mask = 0;
 623         if (bpmem.blendmode.alphaupdate)
 624                 color_mask = D3DCOLORWRITEENABLE_ALPHA;
 625         if (bpmem.blendmode.colorupdate)
 626                 color_mask |= D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE;
 627         D3D::SetRenderState(D3DRS_COLORWRITEENABLE, color_mask);
 628 }
 629
 630 u32 Renderer::AccessEFB(EFBAccessType type, int x, int y)
 631 {
 632         if (!g_ActiveConfig.bEFBAccessEnable)
 633                 return 0;
 634
 635         if (type == POKE_Z || type == POKE_COLOR)
 636         {
 637                 static bool alert_only_once = true;
 638                 if (!alert_only_once) return 0;
 639                 PanicAlert("Poke EFB not implemented");
 640                 alert_only_once = false;
 641                 return 0;
 642         }
 643
 644         // Get the working buffer
 645         LPDIRECT3DSURFACE9 pBuffer = (type == PEEK_Z || type == POKE_Z) ?
 646                 FBManager.GetEFBDepthRTSurface() : FBManager.GetEFBColorRTSurface();
 647         // Get the temporal buffer to move 1pixel data
 648         LPDIRECT3DSURFACE9 RBuffer = (type == PEEK_Z || type == POKE_Z) ?
 649                 FBManager.GetEFBDepthReadSurface() : FBManager.GetEFBColorReadSurface();
 650         // Get the memory buffer that can be locked
 651         LPDIRECT3DSURFACE9 pOffScreenBuffer = (type == PEEK_Z || type == POKE_Z) ?
 652                 FBManager.GetEFBDepthOffScreenRTSurface() : FBManager.GetEFBColorOffScreenRTSurface();
 653         // Get the buffer format
 654         D3DFORMAT BufferFormat = (type == PEEK_Z || type == POKE_Z) ?
 655                 FBManager.GetEFBDepthRTSurfaceFormat() : FBManager.GetEFBColorRTSurfaceFormat();
 656         D3DFORMAT ReadBufferFormat = (type == PEEK_Z || type == POKE_Z) ?
 657                 FBManager.GetEFBDepthReadSurfaceFormat() : BufferFormat;
 658
 659         if (BufferFormat == D3DFMT_D24X8)
 660                 return 0;
 661
 662         D3DLOCKED_RECT drect;
 663
 664         // Buffer not found alert
 665         if (!pBuffer) {
 666                 PanicAlert("No %s!", (type == PEEK_Z || type == POKE_Z) ? "Z-Buffer" : "Color EFB");
 667                 return 0;
 668         }
 669         // Get the rectangular target region covered by the EFB pixel.
 670
 671         EFBRectangle efbPixelRc;
 672         efbPixelRc.left = x;
 673         efbPixelRc.top = y;
 674         efbPixelRc.right = x + 1;
 675         efbPixelRc.bottom = y + 1;
 676
 677         TargetRectangle targetPixelRc = Renderer::ConvertEFBRectangle(efbPixelRc);
 678
 679         u32 z = 0;
 680         float val = 0.0f;
 681         HRESULT hr;
 682         RECT RectToLock;
 683         RectToLock.bottom = targetPixelRc.bottom;
 684         RectToLock.left = targetPixelRc.left;
 685         RectToLock.right = targetPixelRc.right;
 686         RectToLock.top = targetPixelRc.top;
 687         if (type == PEEK_Z)
 688         {
 689                 RECT PixelRect;
 690                 PixelRect.bottom = 4;
 691                 PixelRect.left = 0;
 692                 PixelRect.right = 4;
 693                 PixelRect.top = 0;
 694                 RectToLock.bottom+=2;
 695                 RectToLock.right+=1;
 696                 RectToLock.top-=1;
 697                 RectToLock.left-=2;
 698                 if ((RectToLock.bottom - RectToLock.top) > 4)
 699                         RectToLock.bottom--;
 700                 if ((RectToLock.right - RectToLock.left) > 4)
 701                         RectToLock.left++;
 702                 ResetAPIState(); // Reset any game specific settings
 703                 hr = D3D::dev->SetDepthStencilSurface(NULL);
 704                 hr = D3D::dev->SetRenderTarget(0, RBuffer);
 705                 if (FAILED(hr))
 706                 {
 707                         PanicAlert("unable to set pixel render buffer");
 708                         return 0;
 709                 }
 710                 D3DVIEWPORT9 vp;
 711                 // Stretch picture with increased internal resolution
 712                 vp.X = 0;
 713                 vp.Y = 0;
 714                 vp.Width  = 4;
 715                 vp.Height = 4;
 716                 vp.MinZ = 0.0f;
 717                 vp.MaxZ = 1.0f;
 718                 hr = D3D::dev->SetViewport(&vp);
 719                 if (FAILED(hr))
 720                 {
 721                         PanicAlert("unable to set pixel viewport");
 722                         return 0;
 723                 }
 724                 float colmat[16] = {0.0f};
 725                 float fConstAdd[4] = {0.0f};
 726                 colmat[0] = colmat[5] = colmat[10] = 1.0f;
 727                 PixelShaderManager::SetColorMatrix(colmat, fConstAdd); // set transformation
 728                 EFBRectangle source_rect;
 729                 LPDIRECT3DTEXTURE9 read_texture = FBManager.GetEFBDepthTexture(source_rect);
 730
 731                 D3D::ChangeSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
 732
 733                 D3D::drawShadedTexQuad(
 734                         read_texture,
 735                         &RectToLock,
 736                         Renderer::GetFullTargetWidth(),
 737                         Renderer::GetFullTargetHeight(),
 738                         4, 4,
 739                         (BufferFormat == FOURCC_RAWZ) ? PixelShaderCache::GetColorMatrixProgram(0) : PixelShaderCache::GetDepthMatrixProgram(0),
 740                         VertexShaderCache::GetSimpleVertexShader(0));
 741
 742                 D3D::RefreshSamplerState(0, D3DSAMP_MINFILTER);
 743
 744                 hr = D3D::dev->SetRenderTarget(0, FBManager.GetEFBColorRTSurface());
 745                 hr = D3D::dev->SetDepthStencilSurface(FBManager.GetEFBDepthRTSurface());
 746                 RestoreAPIState();
 747                 RectToLock.bottom = 4;
 748                 RectToLock.left = 0;
 749                 RectToLock.right = 4;
 750                 RectToLock.top = 0;
 751         }
 752         else
 753         {
 754                 hr = D3D::dev->StretchRect(pBuffer, &RectToLock, RBuffer, NULL, D3DTEXF_NONE);
 755                 //change the rect to lock the entire one pixel buffer
 756                 RectToLock.bottom = 1;
 757                 RectToLock.left = 0;
 758                 RectToLock.right = 1;
 759                 RectToLock.top = 0;
 760         }
 761         if (FAILED(hr))
 762         {
 763                 PanicAlert("Unable to stretch data to buffer");
 764                 return 0;
 765         }
 766         // Retrieve the pixel data to the local memory buffer
 767         D3D::dev->GetRenderTargetData(RBuffer, pOffScreenBuffer);
 768         if (FAILED(hr))
 769         {
 770                 PanicAlert("Unable to copy data to mem buffer");
 771                 return 0;
 772         }
 773
 774
 775
 776         // The surface is good.. lock it
 777         if ((hr = pOffScreenBuffer->LockRect(&drect, &RectToLock, D3DLOCK_READONLY)) != D3D_OK)
 778         {
 779                 PanicAlert("ERROR: %s", hr == D3DERR_WASSTILLDRAWING ? "Still drawing" : hr == D3DERR_INVALIDCALL ? "Invalid call" : "w00t");
 780                 return 0;
 781         }
 782
 783         switch (type) {
 784                 case PEEK_Z:
 785                         {
 786                                 switch (ReadBufferFormat)
 787                                 {
 788                                 case D3DFMT_R32F:
 789                                         val = ((float*)drect.pBits)[6];
 790                                         break;
 791                                 default:
 792                                         float ffrac = 1.0f/255.0f;
 793                                         z = ((u32*)drect.pBits)[6];
 794                                         val =   ((float)((z>>16) & 0xFF)) * ffrac;
 795                                         ffrac*= 1 / 255.0f;
 796                                         val +=  ((float)((z>>8) & 0xFF)) * ffrac;
 797                                         ffrac*= 1 / 255.0f;
 798                                         val +=  ((float)(z & 0xFF)) * ffrac;
 799                                         break;
 800                                 };
 801                                 z = ((u32)(val * 0xffffff));
 802                         }
 803                         break;
 804
 805                 case PEEK_COLOR:
 806                         z = ((u32 *)drect.pBits)[0];
 807                         break;
 808                 case POKE_COLOR:
 809
 810                 // TODO: Implement POKE_Z and POKE_COLOR
 811                 default:
 812                         break;
 813         }
 814
 815         pOffScreenBuffer->UnlockRect();
 816         // TODO: in RE0 this value is often off by one, which causes lighting to disappear
 817         return z;
 818 }
 819
 820 // Called from VertexShaderManager
 821 void UpdateViewport()
 822 {
 823         // reversed gxsetviewport(xorig, yorig, width, height, nearz, farz)
 824         // [0] = width/2
 825         // [1] = height/2
 826         // [2] = 16777215 * (farz - nearz)
 827         // [3] = xorig + width/2 + 342
 828         // [4] = yorig + height/2 + 342
 829         // [5] = 16777215 * farz
 830         const int old_fulltarget_w = s_Fulltarget_width;
 831         const int old_fulltarget_h = s_Fulltarget_height;
 832
 833         int scissorXOff = bpmem.scissorOffset.x * 2;
 834         int scissorYOff = bpmem.scissorOffset.y * 2;
 835
 836         float MValueX = Renderer::GetTargetScaleX();
 837         float MValueY = Renderer::GetTargetScaleY();
 838
 839         int Xstride =  (s_Fulltarget_width - s_target_width) / 2;
 840         int Ystride =  (s_Fulltarget_height - s_target_height) / 2;
 841
 842         D3DVIEWPORT9 vp;
 843
 844         // Stretch picture with increased internal resolution
 845         int X = (int)(ceil(xfregs.rawViewport[3] - xfregs.rawViewport[0] - (scissorXOff)) * MValueX) + Xstride;
 846         int Y = (int)(ceil(xfregs.rawViewport[4] + xfregs.rawViewport[1] - (scissorYOff)) * MValueY) + Ystride;
 847         int Width  = (int)ceil((int)(2 * xfregs.rawViewport[0]) * MValueX);
 848         int Height = (int)ceil((int)(-2 * xfregs.rawViewport[1]) * MValueY);
 849         if (Width < 0)
 850         {
 851                 X += Width;
 852                 Width*=-1;
 853         }
 854         if (Height < 0)
 855         {
 856                 Y += Height;
 857                 Height *= -1;
 858         }
 859         bool sizeChanged = false;
 860         if (X < 0)
 861         {
 862                 s_Fulltarget_width -= 2 * X;
 863                 X = 0;
 864                 sizeChanged=true;
 865         }
 866         if (Y < 0)
 867         {
 868                 s_Fulltarget_height -= 2 * Y;
 869                 Y = 0;
 870                 sizeChanged = true;
 871         }
 872         if (!IS_AMD)
 873         {
 874                 if(X + Width > s_Fulltarget_width)
 875                 {
 876                         s_Fulltarget_width += (X + Width - s_Fulltarget_width) * 2;
 877                         sizeChanged = true;
 878                 }
 879                 if(Y + Height > s_Fulltarget_height)
 880                 {
 881                         s_Fulltarget_height += (Y + Height - s_Fulltarget_height) * 2;
 882                         sizeChanged = true;
 883                 }
 884         }
 885         if (sizeChanged)
 886         {
 887                 D3DCAPS9 caps = D3D::GetCaps();
 888                 // Make sure that the requested size is actually supported by the GFX driver
 889                 if (s_Fulltarget_width > caps.MaxTextureWidth || s_Fulltarget_height > caps.MaxTextureHeight)
 890                 {
 891                         // Skip EFB recreation and viewport setting. Most likely causes glitches in this case, but prevents crashes at least
 892                         ERROR_LOG(VIDEO, "Tried to set a viewport which is too wide to emulate with Direct3D9. Requested EFB size is %dx%d, keeping the %dx%d EFB now\n", s_Fulltarget_width, s_Fulltarget_height, old_fulltarget_w, old_fulltarget_h);
 893
 894                         // Fix the viewport to fit to the old EFB size, TODO: Check this for off-by-one errors
 895                         X *= old_fulltarget_w / s_Fulltarget_width;
 896                         Y *= old_fulltarget_h / s_Fulltarget_height;
 897                         Width *= old_fulltarget_w / s_Fulltarget_width;
 898                         Height *= old_fulltarget_h / s_Fulltarget_height;
 899
 900                         s_Fulltarget_width = old_fulltarget_w;
 901                         s_Fulltarget_height = old_fulltarget_h;
 902                 }
 903                 else
 904                 {
 905                         D3D::dev->SetRenderTarget(0, D3D::GetBackBufferSurface());
 906                         D3D::dev->SetDepthStencilSurface(D3D::GetBackBufferDepthSurface());
 907                         FBManager.Destroy();
 908                         FBManager.Create();
 909                         D3D::dev->SetRenderTarget(0, FBManager.GetEFBColorRTSurface());
 910                         D3D::dev->SetDepthStencilSurface(FBManager.GetEFBDepthRTSurface());
 911                 }
 912         }
 913         vp.X = X;
 914         vp.Y = Y;
 915         vp.Width = Width;
 916         vp.Height = Height;
 917
 918         // Some games set invalids values for z min and z max so fix them to the max an min alowed and let the shaders do this work
 919         vp.MinZ = 0.0f; // (xfregs.rawViewport[5] - xfregs.rawViewport[2]) / 16777216.0f;
 920         vp.MaxZ = 1.0f; // xfregs.rawViewport[5] / 16777216.0f;
 921         D3D::dev->SetViewport(&vp);
 922 }
 923
 924 void Renderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable, u32 color, u32 z)
 925 {
 926         // Update the view port for clearing the picture
 927         TargetRectangle targetRc = Renderer::ConvertEFBRectangle(rc);
 928         D3DVIEWPORT9 vp;
 929         vp.X = targetRc.left;
 930         vp.Y = targetRc.top;
 931         vp.Width  = targetRc.GetWidth();
 932         vp.Height = targetRc.GetHeight();
 933         vp.MinZ = 0.0;
 934         vp.MaxZ = 1.0;
 935         D3D::dev->SetViewport(&vp);
 936
 937         // Always set the scissor in case it was set by the game and has not been reset
 938         RECT sicr;
 939         sicr.left   = targetRc.left;
 940         sicr.top    = targetRc.top;
 941         sicr.right  = targetRc.right;
 942         sicr.bottom = targetRc.bottom;
 943         D3D::dev->SetScissorRect(&sicr);
 944         D3D::ChangeRenderState(D3DRS_ALPHABLENDENABLE, false);
 945         if (zEnable)
 946                 D3D::ChangeRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
 947         D3D::drawClearQuad(color, (z & 0xFFFFFF) / float(0xFFFFFF), PixelShaderCache::GetClearProgram(), VertexShaderCache::GetClearVertexShader());
 948         if (zEnable)
 949                 D3D::RefreshRenderState(D3DRS_ZFUNC);
 950         D3D::RefreshRenderState(D3DRS_ALPHABLENDENABLE);
 951         UpdateViewport();
 952         SetScissorRect();
 953 }
 954
 955 void Renderer::SetBlendMode(bool forceUpdate)
 956 {
 957         if (bpmem.blendmode.logicopenable)
 958                 return;
 959
 960         if (bpmem.blendmode.subtract && bpmem.blendmode.blendenable)
 961         {
 962                 D3D::SetRenderState(D3DRS_ALPHABLENDENABLE, true);
 963                 D3D::SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_REVSUBTRACT);
 964                 D3D::SetRenderState(D3DRS_SRCBLEND, d3dSrcFactors[1]);
 965                 D3D::SetRenderState(D3DRS_DESTBLEND, d3dDestFactors[1]);
 966         }
 967         else
 968         {
 969                 D3D::SetRenderState(D3DRS_ALPHABLENDENABLE, bpmem.blendmode.blendenable && (!( bpmem.blendmode.srcfactor == 1 && bpmem.blendmode.dstfactor == 0)));
 970                 if (bpmem.blendmode.blendenable && (!( bpmem.blendmode.srcfactor == 1 && bpmem.blendmode.dstfactor == 0)))
 971                 {
 972                         D3D::SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
 973                         D3D::SetRenderState(D3DRS_SRCBLEND, d3dSrcFactors[bpmem.blendmode.srcfactor]);
 974                         D3D::SetRenderState(D3DRS_DESTBLEND, d3dDestFactors[bpmem.blendmode.dstfactor]);
 975                 }
 976         }
 977 }
 978
 979
 980
 981 void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,const EFBRectangle& rc)
 982 {
 983         if (g_bSkipCurrentFrame || (!XFBWrited && !g_ActiveConfig.bUseRealXFB) || !fbWidth || !fbHeight)
 984         {
 985                 g_VideoInitialize.pCopiedToXFB(false);
 986                 return;
 987         }
 988         // this function is called after the XFB field is changed, not after
 989         // EFB is copied to XFB. In this way, flickering is reduced in games
 990         // and seems to also give more FPS in ZTP
 991
 992         if (field == FIELD_LOWER) xfbAddr -= fbWidth * 2;
 993         u32 xfbCount = 0;
 994         const XFBSource** xfbSourceList = FBManager.GetXFBSource(xfbAddr, fbWidth, fbHeight, xfbCount);
 995         if ((!xfbSourceList || xfbCount == 0) && g_ActiveConfig.bUseXFB && !g_ActiveConfig.bUseRealXFB)
 996         {
 997                 g_VideoInitialize.pCopiedToXFB(false);
 998                 return;
 999         }
1000
1001         Renderer::ResetAPIState();
1002         // Set the backbuffer as the rendering target
1003         D3D::dev->SetDepthStencilSurface(NULL);
1004         D3D::dev->SetRenderTarget(0, D3D::GetBackBufferSurface());
1005
1006         TargetRectangle dst_rect;
1007         ComputeDrawRectangle(s_backbuffer_width, s_backbuffer_height, false, &dst_rect);
1008         D3DVIEWPORT9 vp;
1009         vp.X = 0;
1010         vp.Y = 0;
1011         vp.Width  = s_backbuffer_width;
1012         vp.Height = s_backbuffer_height;
1013         vp.MinZ = 0.0f;
1014         vp.MaxZ = 1.0f;
1015         D3D::dev->SetViewport(&vp);
1016         D3D::dev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
1017
1018         int X = dst_rect.left;
1019         int Y = dst_rect.top;
1020         int Width  = dst_rect.right - dst_rect.left;
1021         int Height = dst_rect.bottom - dst_rect.top;
1022
1023         if (X < 0) X = 0;
1024         if (Y < 0) Y = 0;
1025         if (X > s_backbuffer_width) X = s_backbuffer_width;
1026         if (Y > s_backbuffer_height) Y = s_backbuffer_height;
1027         if (Width < 0) Width = 0;
1028         if (Height < 0) Height = 0;
1029         if (Width > (s_backbuffer_width - X)) Width = s_backbuffer_width - X;
1030         if (Height > (s_backbuffer_height - Y)) Height = s_backbuffer_height - Y;
1031         vp.X = X;
1032         vp.Y = Y;
1033         vp.Width = Width;
1034         vp.Height = Height;
1035         vp.MinZ = 0.0f;
1036         vp.MaxZ = 1.0f;
1037
1038         D3D::dev->SetViewport(&vp);
1039
1040         D3D::ChangeSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
1041         D3D::ChangeSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
1042
1043         if(g_ActiveConfig.bUseXFB)
1044         {
1045                 const XFBSource* xfbSource;
1046
1047                 // draw each xfb source
1048                 for (u32 i = 0; i < xfbCount; ++i)
1049                 {
1050                         xfbSource = xfbSourceList[i];
1051                         MathUtil::Rectangle<float> sourceRc;
1052
1053                         sourceRc.left = 0;
1054                         sourceRc.top = 0;
1055                         sourceRc.right = xfbSource->texWidth;
1056                         sourceRc.bottom = xfbSource->texHeight;
1057
1058                         MathUtil::Rectangle<float> drawRc;
1059
1060                         if (g_ActiveConfig.bUseXFB && !g_ActiveConfig.bUseRealXFB)
1061                         {
1062                                 // use virtual xfb with offset
1063                                 int xfbHeight = xfbSource->srcHeight;
1064                                 int xfbWidth = xfbSource->srcWidth;
1065                                 int hOffset = ((s32)xfbSource->srcAddr - (s32)xfbAddr) / ((s32)fbWidth * 2);
1066
1067                                 drawRc.bottom = 1.0f - 2.0f * ((hOffset) / (float)fbHeight);
1068                                 drawRc.top = 1.0f - 2.0f * ((hOffset + xfbHeight) / (float)fbHeight);
1069                                 drawRc.left = -(xfbWidth / (float)fbWidth);
1070                                 drawRc.right = (xfbWidth / (float)fbWidth);
1071
1072
1073                                 if (!g_ActiveConfig.bAutoScale)
1074                                 {
1075                                         // scale draw area for a 1 to 1 pixel mapping with the draw target
1076                                         float vScale = (float)fbHeight / (float)s_backbuffer_height;
1077                                         float hScale = (float)fbWidth / (float)s_backbuffer_width;
1078
1079                                         drawRc.top *= vScale;
1080                                         drawRc.bottom *= vScale;
1081                                         drawRc.left *= hScale;
1082                                         drawRc.right *= hScale;
1083                                 }
1084                         }
1085                         else
1086                         {
1087                                 drawRc.top = -1;
1088                                 drawRc.bottom = 1;
1089                                 drawRc.left = -1;
1090                                 drawRc.right = 1;
1091                         }
1092
1093                         D3D::drawShadedTexSubQuad(xfbSource->texture,&sourceRc,xfbSource->texWidth,xfbSource->texHeight,&drawRc,Width,Height,PixelShaderCache::GetColorCopyProgram(0),VertexShaderCache::GetSimpleVertexShader(0));
1094                 }
1095         }
1096         else
1097         {
1098                 TargetRectangle targetRc = Renderer::ConvertEFBRectangle(rc);
1099                 LPDIRECT3DTEXTURE9 read_texture = FBManager.GetEFBColorTexture(rc);
1100                 D3D::drawShadedTexQuad(read_texture,targetRc.AsRECT(),Renderer::GetFullTargetWidth(),Renderer::GetFullTargetHeight(),Width,Height,PixelShaderCache::GetColorCopyProgram(g_Config.iMultisampleMode),VertexShaderCache::GetSimpleVertexShader(g_Config.iMultisampleMode));
1101         }
1102         D3D::RefreshSamplerState(0, D3DSAMP_MINFILTER);
1103         D3D::RefreshSamplerState(0, D3DSAMP_MAGFILTER);
1104         vp.X = 0;
1105         vp.Y = 0;
1106         vp.Width  = s_backbuffer_width;
1107         vp.Height = s_backbuffer_height;
1108         vp.MinZ = 0.0f;
1109         vp.MaxZ = 1.0f;
1110         D3D::dev->SetViewport(&vp);
1111         if(s_bScreenshot)
1112         {
1113                 s_criticalScreenshot.Enter();
1114                 HRESULT hr = D3D::dev->GetRenderTargetData(D3D::GetBackBufferSurface(),ScreenShootMEMSurface);
1115                 if(FAILED(hr))
1116                 {
1117                         PanicAlert("Error dumping surface data.");
1118                 }
1119                 hr = PD3DXSaveSurfaceToFileA(s_sScreenshotName, D3DXIFF_PNG, ScreenShootMEMSurface, NULL, dst_rect.AsRECT());
1120                 if(FAILED(hr))
1121                 {
1122                         PanicAlert("Error saving screen.");
1123                 }
1124                 s_bScreenshot = false;
1125                 s_criticalScreenshot.Leave();
1126         }
1127         if (g_ActiveConfig.bDumpFrames)
1128         {
1129                 HRESULT hr = D3D::dev->GetRenderTargetData(D3D::GetBackBufferSurface(),ScreenShootMEMSurface);
1130                 if (!s_LastFrameDumped)
1131                 {
1132                         s_recordWidth = dst_rect.GetWidth();
1133                         s_recordHeight = dst_rect.GetHeight();
1134                         s_AVIDumping = AVIDump::Start(EmuWindow::GetParentWnd(), s_recordWidth, s_recordHeight);
1135                         if (!s_AVIDumping)
1136                         {
1137                                 PanicAlert("Error dumping frames to AVI.");
1138                         }
1139                         else
1140                         {
1141                                 char msg [255];
1142                                 sprintf_s(msg,255, "Dumping Frames to \"%sframedump0.avi\" (%dx%d RGB24)", File::GetUserPath(D_DUMPFRAMES_IDX), s_recordWidth, s_recordHeight);
1143                                 OSD::AddMessage(msg, 2000);
1144                         }
1145                 }
1146                 if (s_AVIDumping)
1147                 {
1148                         D3DLOCKED_RECT rect;
1149                         if (SUCCEEDED(ScreenShootMEMSurface->LockRect(&rect, dst_rect.AsRECT(), D3DLOCK_NO_DIRTY_UPDATE | D3DLOCK_NOSYSLOCK | D3DLOCK_READONLY)))
1150                         {
1151                                 char* data = (char*)malloc(3 * s_recordWidth * s_recordHeight);
1152                                 formatBufferDump((const char*)rect.pBits, data, s_recordWidth, s_recordHeight, rect.Pitch);
1153                                 AVIDump::AddFrame(data);
1154                                 free(data);
1155                                 ScreenShootMEMSurface->UnlockRect();
1156                         }
1157                 }
1158                 s_LastFrameDumped = true;
1159         }
1160         else
1161         {
1162                 if (s_LastFrameDumped && s_AVIDumping)
1163                 {
1164                         AVIDump::Stop();
1165                         s_AVIDumping = false;
1166                 }
1167                 s_LastFrameDumped = false;
1168         }
1169
1170         // Finish up the current frame, print some stats
1171         if (g_ActiveConfig.bShowFPS)
1172         {
1173                 char fps[20];
1174                 StringCchPrintfA(fps, 20, "FPS: %d\n", s_fps);
1175                 D3D::font.DrawTextScaled(0, 30, 20, 20, 0.0f, 0xFF00FFFF, fps, false);
1176         }
1177         Renderer::DrawDebugText();
1178
1179         if (g_ActiveConfig.bOverlayStats)
1180         {
1181                 Statistics::ToString(st);
1182                 D3D::font.DrawTextScaled(0, 30, 20, 20, 0.0f, 0xFF00FFFF, st, false);
1183         }
1184         else if (g_ActiveConfig.bOverlayProjStats)
1185         {
1186                 Statistics::ToStringProj(st);
1187                 D3D::font.DrawTextScaled(0, 30, 20, 20, 0.0f, 0xFF00FFFF, st, false);
1188         }
1189
1190
1191         OSD::DrawMessages();
1192
1193         D3D::EndFrame();
1194
1195         frameCount++;
1196         TextureCache::Cleanup();
1197
1198         // Make any new configuration settings active.
1199         UpdateActiveConfig();
1200         WindowResized = false;
1201         CheckForResize();
1202
1203         bool xfbchanged = false;
1204
1205         if (s_XFB_width != fbWidth || s_XFB_height != fbHeight)
1206         {
1207                 xfbchanged = true;
1208                 s_XFB_width = fbWidth;
1209                 s_XFB_height = fbHeight;
1210                 if (s_XFB_width < 1) s_XFB_width = MAX_XFB_WIDTH;
1211                 if (s_XFB_width > MAX_XFB_WIDTH) s_XFB_width = MAX_XFB_WIDTH;
1212                 if (s_XFB_height < 1) s_XFB_height = MAX_XFB_HEIGHT;
1213                 if (s_XFB_height > MAX_XFB_HEIGHT) s_XFB_height = MAX_XFB_HEIGHT;
1214         }
1215
1216         u32 newAA = g_ActiveConfig.iMultisampleMode;
1217         u32 newEFBScale = g_ActiveConfig.iEFBScale;
1218         if (newAA != s_LastAA || newEFBScale != s_LastEFBScale || xfbchanged || WindowResized)
1219         {
1220                 s_LastAA = newAA;
1221                 s_LastEFBScale = newEFBScale;
1222
1223                 ComputeDrawRectangle(s_backbuffer_width, s_backbuffer_height, false, &dst_rect);
1224
1225                 if(g_ActiveConfig.bUseRealXFB)
1226                 {
1227                         xScale = yScale = 1.0f;
1228                 }
1229                 else
1230                 {
1231                         xScale = (float)(dst_rect.right - dst_rect.left) / (float)s_XFB_width;
1232                         yScale = (float)(dst_rect.bottom - dst_rect.top) / (float)s_XFB_height;
1233                 }
1234
1235                 float SupersampleCoeficient = s_LastAA + 1;
1236                 switch(s_LastEFBScale)
1237                 {
1238                         case 0:
1239                                 EFBxScale = xScale;
1240                                 EFByScale = yScale;
1241                                 break;
1242                         case 1:
1243                                 EFBxScale = ceilf(xScale);
1244                                 EFByScale = ceilf(yScale);
1245                                 break;
1246                         default:
1247                                 EFBxScale = g_ActiveConfig.iEFBScale - 1;
1248                                 EFByScale = EFBxScale;
1249                                 break;
1250                 };
1251
1252                 EFBxScale *= SupersampleCoeficient;
1253                 EFByScale *= SupersampleCoeficient;
1254                 s_target_width  = EFB_WIDTH * EFBxScale;
1255                 s_target_height = EFB_HEIGHT * EFByScale;
1256                 D3D::dev->SetRenderTarget(0, D3D::GetBackBufferSurface());
1257                 D3D::dev->SetDepthStencilSurface(D3D::GetBackBufferDepthSurface());
1258                 if (WindowResized)
1259                 {
1260                         SetupDeviceObjects();
1261                 }
1262                 else
1263                 {
1264                         FBManager.Destroy();
1265                         FBManager.Create();
1266                 }
1267                 D3D::dev->SetRenderTarget(0, FBManager.GetEFBColorRTSurface());
1268                 D3D::dev->SetDepthStencilSurface(FBManager.GetEFBDepthRTSurface());
1269         }
1270
1271         // ---------------------------------------------------------------------
1272         // Count FPS.
1273         // -------------
1274         static int fpscount = 0;
1275         static unsigned long lasttime = 0;
1276         if (Common::Timer::GetTimeMs() - lasttime >= 1000)
1277         {
1278                 lasttime = Common::Timer::GetTimeMs();
1279                 s_fps = fpscount;
1280                 fpscount = 0;
1281         }
1282         if (XFBWrited)
1283                 ++fpscount;
1284
1285         // Begin new frame
1286         // Set default viewport and scissor, for the clear to work correctly
1287         stats.ResetFrame();
1288
1289         // Flip/present backbuffer to frontbuffer here
1290         D3D::Present();
1291         D3D::BeginFrame();
1292         Renderer::RestoreAPIState();
1293         D3D::dev->SetRenderTarget(0, FBManager.GetEFBColorRTSurface());
1294         D3D::dev->SetDepthStencilSurface(FBManager.GetEFBDepthRTSurface());
1295         UpdateViewport();
1296         VertexShaderManager::SetViewportChanged();
1297         g_VideoInitialize.pCopiedToXFB(XFBWrited || g_ActiveConfig.bUseRealXFB);
1298         XFBWrited = false;
1299 }
1300
1301 void Renderer::ResetAPIState()
1302 {
1303         D3D::SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
1304         D3D::SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
1305         D3D::SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
1306         D3D::SetRenderState(D3DRS_ZENABLE, FALSE);
1307         D3D::SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
1308         DWORD color_mask = D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE;
1309         D3D::SetRenderState(D3DRS_COLORWRITEENABLE, color_mask);
1310 }
1311
1312 void Renderer::RestoreAPIState()
1313 {
1314         // Gets us back into a more game-like state.
1315         D3D::SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
1316         UpdateViewport();
1317         SetScissorRect();
1318         if (bpmem.zmode.testenable)
1319                 D3D::SetRenderState(D3DRS_ZENABLE, TRUE);
1320         if (bpmem.zmode.updateenable)
1321                 D3D::SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
1322         SetColorMask();
1323         SetLogicOpMode();
1324 }
1325
1326 void Renderer::SetGenerationMode()
1327 {
1328         D3D::SetRenderState(D3DRS_CULLMODE, d3dCullModes[bpmem.genMode.cullmode]);
1329 }
1330
1331 void Renderer::SetDepthMode()
1332 {
1333         if (bpmem.zmode.testenable)
1334         {
1335                 D3D::SetRenderState(D3DRS_ZENABLE, TRUE);
1336                 D3D::SetRenderState(D3DRS_ZWRITEENABLE, bpmem.zmode.updateenable);
1337                 D3D::SetRenderState(D3DRS_ZFUNC, d3dCmpFuncs[bpmem.zmode.func]);
1338         }
1339         else
1340         {
1341                 D3D::SetRenderState(D3DRS_ZENABLE, FALSE);
1342                 D3D::SetRenderState(D3DRS_ZWRITEENABLE, FALSE);  // ??
1343         }
1344 }
1345
1346 void Renderer::SetLogicOpMode()
1347 {
1348         if (bpmem.blendmode.logicopenable && bpmem.blendmode.logicmode != 3)
1349         {
1350                 D3D::SetRenderState(D3DRS_ALPHABLENDENABLE, true);
1351                 D3D::SetRenderState(D3DRS_BLENDOP, d3dLogicOpop[bpmem.blendmode.logicmode]);
1352                 D3D::SetRenderState(D3DRS_SRCBLEND, d3dLogicOpSrcFactors[bpmem.blendmode.logicmode]);
1353                 D3D::SetRenderState(D3DRS_DESTBLEND, d3dLogicOpDestFactors[bpmem.blendmode.logicmode]);
1354         }
1355         else
1356         {
1357                 SetBlendMode(true);
1358         }
1359 }
1360
1361 void Renderer::SetDitherMode()
1362 {
1363         D3D::SetRenderState(D3DRS_DITHERENABLE, bpmem.blendmode.dither);
1364 }
1365
1366 void Renderer::SetLineWidth()
1367 {
1368         // We can't change line width in D3D unless we use ID3DXLine
1369         float fratio = xfregs.rawViewport[0] != 0 ? Renderer::GetTargetScaleX() : 1.0f;
1370         float psize = bpmem.lineptwidth.linesize * fratio / 6.0f;
1371         D3D::SetRenderState(D3DRS_POINTSIZE, *((DWORD*)&psize));
1372 }
1373
1374 void Renderer::SetSamplerState(int stage, int texindex)
1375 {
1376         const FourTexUnits &tex = bpmem.tex[texindex];
1377         const TexMode0 &tm0 = tex.texMode0[stage];
1378         const TexMode1 &tm1 = tex.texMode1[stage];
1379
1380         D3DTEXTUREFILTERTYPE min, mag, mip;
1381         if (g_ActiveConfig.bForceFiltering)
1382         {
1383                 min = mag = mip = D3DTEXF_LINEAR;
1384         }
1385         else
1386         {
1387                 min = (tm0.min_filter & 4) ? D3DTEXF_LINEAR : D3DTEXF_POINT;
1388                 mag = tm0.mag_filter ? D3DTEXF_LINEAR : D3DTEXF_POINT;
1389                 mip = (tm0.min_filter == 8) ? D3DTEXF_NONE : d3dMipFilters[tm0.min_filter & 3];
1390                 if((tm0.min_filter & 3) && (tm0.min_filter != 8) && ((tm1.max_lod >> 4) == 0))
1391                         mip = D3DTEXF_NONE;
1392         }
1393         if (texindex)
1394                 stage += 4;
1395
1396         if (mag == D3DTEXF_LINEAR && min == D3DTEXF_LINEAR && g_ActiveConfig.iMaxAnisotropy > 1)
1397         {
1398                 min = D3DTEXF_ANISOTROPIC;
1399         }
1400         D3D::SetSamplerState(stage, D3DSAMP_MINFILTER, min);
1401         D3D::SetSamplerState(stage, D3DSAMP_MAGFILTER, mag);
1402         D3D::SetSamplerState(stage, D3DSAMP_MIPFILTER, mip);
1403
1404         D3D::SetSamplerState(stage, D3DSAMP_ADDRESSU, d3dClamps[tm0.wrap_s]);
1405         D3D::SetSamplerState(stage, D3DSAMP_ADDRESSV, d3dClamps[tm0.wrap_t]);
1406         //float SuperSampleCoeficient = (s_LastAA < 3)? s_LastAA + 1 : s_LastAA - 1;// uncoment this changes to conserve detail when incresing ssaa level
1407         float lodbias = (tm0.lod_bias / 32.0f);// + (s_LastAA)?(log(SuperSampleCoeficient) / log(2.0f)):0;
1408         D3D::SetSamplerState(stage, D3DSAMP_MIPMAPLODBIAS, *(DWORD*)&lodbias);
1409         D3D::SetSamplerState(stage, D3DSAMP_MAXMIPLEVEL, tm1.min_lod >> 4);
1410 }
1411
1412 void Renderer::SetInterlacingMode()
1413 {
1414         // TODO
1415 }
1416
1417 // Save screenshot
1418 void Renderer::SetScreenshot(const char *filename)
1419 {
1420         s_criticalScreenshot.Enter();
1421         strcpy_s(s_sScreenshotName, filename);
1422         s_bScreenshot = true;
1423         s_criticalScreenshot.Leave();
1424 }