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         // Get the working buffer
 636         LPDIRECT3DSURFACE9 pBuffer = (type == PEEK_Z || type == POKE_Z) ?
 637                 FBManager.GetEFBDepthRTSurface() : FBManager.GetEFBColorRTSurface();
 638         // Get the temporal buffer to move 1pixel data
 639         LPDIRECT3DSURFACE9 RBuffer = (type == PEEK_Z || type == POKE_Z) ?
 640                 FBManager.GetEFBDepthReadSurface() : FBManager.GetEFBColorReadSurface();
 641         // Get the memory buffer that can be locked
 642         LPDIRECT3DSURFACE9 pOffScreenBuffer = (type == PEEK_Z || type == POKE_Z) ?
 643                 FBManager.GetEFBDepthOffScreenRTSurface() : FBManager.GetEFBColorOffScreenRTSurface();
 644         // Get the buffer format
 645         D3DFORMAT BufferFormat = (type == PEEK_Z || type == POKE_Z) ?
 646                 FBManager.GetEFBDepthRTSurfaceFormat() : FBManager.GetEFBColorRTSurfaceFormat();
 647         D3DFORMAT ReadBufferFormat = (type == PEEK_Z || type == POKE_Z) ?
 648                 FBManager.GetEFBDepthReadSurfaceFormat() : BufferFormat;
 649
 650         if (BufferFormat == D3DFMT_D24X8)
 651                 return 0;
 652
 653         D3DLOCKED_RECT drect;
 654
 655         // Buffer not found alert
 656         if (!pBuffer) {
 657                 PanicAlert("No %s!", (type == PEEK_Z || type == POKE_Z) ? "Z-Buffer" : "Color EFB");
 658                 return 0;
 659         }
 660         // Get the rectangular target region covered by the EFB pixel.
 661
 662         EFBRectangle efbPixelRc;
 663         efbPixelRc.left = x;
 664         efbPixelRc.top = y;
 665         efbPixelRc.right = x + 1;
 666         efbPixelRc.bottom = y + 1;
 667
 668         TargetRectangle targetPixelRc = Renderer::ConvertEFBRectangle(efbPixelRc);
 669
 670         u32 z = 0;
 671         float val = 0.0f;
 672         HRESULT hr;
 673         RECT RectToLock;
 674         RectToLock.bottom = targetPixelRc.bottom;
 675         RectToLock.left = targetPixelRc.left;
 676         RectToLock.right = targetPixelRc.right;
 677         RectToLock.top = targetPixelRc.top;
 678         if (type == PEEK_Z)
 679         {
 680                 RECT PixelRect;
 681                 PixelRect.bottom = 4;
 682                 PixelRect.left = 0;
 683                 PixelRect.right = 4;
 684                 PixelRect.top = 0;
 685                 RectToLock.bottom+=2;
 686                 RectToLock.right+=1;
 687                 RectToLock.top-=1;
 688                 RectToLock.left-=2;
 689                 if ((RectToLock.bottom - RectToLock.top) > 4)
 690                         RectToLock.bottom--;
 691                 if ((RectToLock.right - RectToLock.left) > 4)
 692                         RectToLock.left++;
 693                 ResetAPIState(); // Reset any game specific settings
 694                 hr = D3D::dev->SetDepthStencilSurface(NULL);
 695                 hr = D3D::dev->SetRenderTarget(0, RBuffer);
 696                 if (FAILED(hr))
 697                 {
 698                         PanicAlert("unable to set pixel render buffer");
 699                         return 0;
 700                 }
 701                 D3DVIEWPORT9 vp;
 702                 // Stretch picture with increased internal resolution
 703                 vp.X = 0;
 704                 vp.Y = 0;
 705                 vp.Width  = 4;
 706                 vp.Height = 4;
 707                 vp.MinZ = 0.0f;
 708                 vp.MaxZ = 1.0f;
 709                 hr = D3D::dev->SetViewport(&vp);
 710                 if (FAILED(hr))
 711                 {
 712                         PanicAlert("unable to set pixel viewport");
 713                         return 0;
 714                 }
 715                 float colmat[16] = {0.0f};
 716                 float fConstAdd[4] = {0.0f};
 717                 colmat[0] = colmat[5] = colmat[10] = 1.0f;
 718                 PixelShaderManager::SetColorMatrix(colmat, fConstAdd); // set transformation
 719                 EFBRectangle source_rect;
 720                 LPDIRECT3DTEXTURE9 read_texture = FBManager.GetEFBDepthTexture(source_rect);
 721
 722                 D3D::ChangeSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
 723
 724                 D3D::drawShadedTexQuad(
 725                         read_texture,
 726                         &RectToLock,
 727                         Renderer::GetFullTargetWidth(),
 728                         Renderer::GetFullTargetHeight(),
 729                         4, 4,
 730                         (BufferFormat == FOURCC_RAWZ) ? PixelShaderCache::GetColorMatrixProgram(0) : PixelShaderCache::GetDepthMatrixProgram(0),
 731                         VertexShaderCache::GetSimpleVertexShader(0));
 732
 733                 D3D::RefreshSamplerState(0, D3DSAMP_MINFILTER);
 734
 735                 hr = D3D::dev->SetRenderTarget(0, FBManager.GetEFBColorRTSurface());
 736                 hr = D3D::dev->SetDepthStencilSurface(FBManager.GetEFBDepthRTSurface());
 737                 RestoreAPIState();
 738                 RectToLock.bottom = 4;
 739                 RectToLock.left = 0;
 740                 RectToLock.right = 4;
 741                 RectToLock.top = 0;
 742         }
 743         else
 744         {
 745                 hr = D3D::dev->StretchRect(pBuffer, &RectToLock, RBuffer, NULL, D3DTEXF_NONE);
 746                 //change the rect to lock the entire one pixel buffer
 747                 RectToLock.bottom = 1;
 748                 RectToLock.left = 0;
 749                 RectToLock.right = 1;
 750                 RectToLock.top = 0;
 751         }
 752         if (FAILED(hr))
 753         {
 754                 PanicAlert("Unable to stretch data to buffer");
 755                 return 0;
 756         }
 757         // Retrieve the pixel data to the local memory buffer
 758         D3D::dev->GetRenderTargetData(RBuffer, pOffScreenBuffer);
 759         if (FAILED(hr))
 760         {
 761                 PanicAlert("Unable to copy data to mem buffer");
 762                 return 0;
 763         }
 764
 765
 766
 767         // The surface is good.. lock it
 768         if ((hr = pOffScreenBuffer->LockRect(&drect, &RectToLock, D3DLOCK_READONLY)) != D3D_OK)
 769         {
 770                 PanicAlert("ERROR: %s", hr == D3DERR_WASSTILLDRAWING ? "Still drawing" : hr == D3DERR_INVALIDCALL ? "Invalid call" : "w00t");
 771                 return 0;
 772         }
 773
 774         switch (type) {
 775                 case PEEK_Z:
 776                         {
 777                                 switch (ReadBufferFormat)
 778                                 {
 779                                 case D3DFMT_R32F:
 780                                         val = ((float*)drect.pBits)[6];
 781                                         break;
 782                                 default:
 783                                         float ffrac = 1.0f/255.0f;
 784                                         z = ((u32*)drect.pBits)[6];
 785                                         val =   ((float)((z>>16) & 0xFF)) * ffrac;
 786                                         ffrac*= 1 / 255.0f;
 787                                         val +=  ((float)((z>>8) & 0xFF)) * ffrac;
 788                                         ffrac*= 1 / 255.0f;
 789                                         val +=  ((float)(z & 0xFF)) * ffrac;
 790                                         break;
 791                                 };
 792                                 z = ((u32)(val * 0xffffff));
 793                         }
 794                         break;
 795                 case POKE_Z:
 796                         // TODO: Get that Z value to poke from somewhere
 797                         //((float *)drect.pBits)[0] = val;
 798                         PanicAlert("Poke Z-buffer not implemented");
 799                         break;
 800
 801                 case PEEK_COLOR:
 802                         z = ((u32 *)drect.pBits)[0];
 803                         break;
 804                 case POKE_COLOR:
 805                         // TODO: Get that ARGB value to poke from somewhere
 806                         //((float*)drect.pBits)[0] = val;
 807                         PanicAlert("Poke color EFB not implemented");
 808                         break;
 809         }
 810
 811         pOffScreenBuffer->UnlockRect();
 812         // TODO: in RE0 this value is often off by one, which causes lighting to disappear
 813         return z;
 814 }
 815
 816 // Called from VertexShaderManager
 817 void UpdateViewport()
 818 {
 819         // reversed gxsetviewport(xorig, yorig, width, height, nearz, farz)
 820         // [0] = width/2
 821         // [1] = height/2
 822         // [2] = 16777215 * (farz - nearz)
 823         // [3] = xorig + width/2 + 342
 824         // [4] = yorig + height/2 + 342
 825         // [5] = 16777215 * farz
 826         const int old_fulltarget_w = s_Fulltarget_width;
 827         const int old_fulltarget_h = s_Fulltarget_height;
 828
 829         int scissorXOff = bpmem.scissorOffset.x * 2;
 830         int scissorYOff = bpmem.scissorOffset.y * 2;
 831
 832         float MValueX = Renderer::GetTargetScaleX();
 833         float MValueY = Renderer::GetTargetScaleY();
 834
 835         int Xstride =  (s_Fulltarget_width - s_target_width) / 2;
 836         int Ystride =  (s_Fulltarget_height - s_target_height) / 2;
 837
 838         D3DVIEWPORT9 vp;
 839
 840         // Stretch picture with increased internal resolution
 841         int X = (int)(ceil(xfregs.rawViewport[3] - xfregs.rawViewport[0] - (scissorXOff)) * MValueX) + Xstride;
 842         int Y = (int)(ceil(xfregs.rawViewport[4] + xfregs.rawViewport[1] - (scissorYOff)) * MValueY) + Ystride;
 843         int Width  = (int)ceil((int)(2 * xfregs.rawViewport[0]) * MValueX);
 844         int Height = (int)ceil((int)(-2 * xfregs.rawViewport[1]) * MValueY);
 845         if (Width < 0)
 846         {
 847                 X += Width;
 848                 Width*=-1;
 849         }
 850         if (Height < 0)
 851         {
 852                 Y += Height;
 853                 Height *= -1;
 854         }
 855         bool sizeChanged = false;
 856         if (X < 0)
 857         {
 858                 s_Fulltarget_width -= 2 * X;
 859                 X = 0;
 860                 sizeChanged=true;
 861         }
 862         if (Y < 0)
 863         {
 864                 s_Fulltarget_height -= 2 * Y;
 865                 Y = 0;
 866                 sizeChanged = true;
 867         }
 868         if (!IS_AMD)
 869         {
 870                 if(X + Width > s_Fulltarget_width)
 871                 {
 872                         s_Fulltarget_width += (X + Width - s_Fulltarget_width) * 2;
 873                         sizeChanged = true;
 874                 }
 875                 if(Y + Height > s_Fulltarget_height)
 876                 {
 877                         s_Fulltarget_height += (Y + Height - s_Fulltarget_height) * 2;
 878                         sizeChanged = true;
 879                 }
 880         }
 881         if (sizeChanged)
 882         {
 883                 D3DCAPS9 caps = D3D::GetCaps();
 884                 // Make sure that the requested size is actually supported by the GFX driver
 885                 if (s_Fulltarget_width > caps.MaxTextureWidth || s_Fulltarget_height > caps.MaxTextureHeight)
 886                 {
 887                         // Skip EFB recreation and viewport setting. Most likely cause glitches in this case, but prevents crashes at least
 888                         ERROR_LOG(VIDEO, "Tried to set a viewport which is too wide to emulate with Direct3D9. Requested EFB size is %dx%d\n", s_Fulltarget_width, s_Fulltarget_height);
 889                         s_Fulltarget_width = old_fulltarget_w;
 890                         s_Fulltarget_height = old_fulltarget_h;
 891                         return;
 892                 }
 893                 D3D::dev->SetRenderTarget(0, D3D::GetBackBufferSurface());
 894                 D3D::dev->SetDepthStencilSurface(D3D::GetBackBufferDepthSurface());
 895                 FBManager.Destroy();
 896                 FBManager.Create();
 897                 D3D::dev->SetRenderTarget(0, FBManager.GetEFBColorRTSurface());
 898                 D3D::dev->SetDepthStencilSurface(FBManager.GetEFBDepthRTSurface());
 899         }
 900         vp.X = X;
 901         vp.Y = Y;
 902         vp.Width = Width;
 903         vp.Height = Height;
 904
 905         // 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
 906         vp.MinZ = 0.0f; // (xfregs.rawViewport[5] - xfregs.rawViewport[2]) / 16777216.0f;
 907         vp.MaxZ =1.0f; // xfregs.rawViewport[5] / 16777216.0f;
 908         D3D::dev->SetViewport(&vp);
 909 }
 910
 911 void Renderer::ClearScreen(const EFBRectangle& rc, bool colorEnable, bool alphaEnable, bool zEnable, u32 color, u32 z)
 912 {
 913         // Update the view port for clearing the picture
 914         TargetRectangle targetRc = Renderer::ConvertEFBRectangle(rc);
 915         D3DVIEWPORT9 vp;
 916         vp.X = targetRc.left;
 917         vp.Y = targetRc.top;
 918         vp.Width  = targetRc.GetWidth();
 919         vp.Height = targetRc.GetHeight();
 920         vp.MinZ = 0.0;
 921         vp.MaxZ = 1.0;
 922         D3D::dev->SetViewport(&vp);
 923
 924         // Always set the scissor in case it was set by the game and has not been reset
 925         RECT sicr;
 926         sicr.left   = targetRc.left;
 927         sicr.top    = targetRc.top;
 928         sicr.right  = targetRc.right;
 929         sicr.bottom = targetRc.bottom;
 930         D3D::dev->SetScissorRect(&sicr);
 931         D3D::ChangeRenderState(D3DRS_ALPHABLENDENABLE, false);
 932         if (zEnable)
 933                 D3D::ChangeRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
 934         D3D::drawClearQuad(color, (z & 0xFFFFFF) / float(0xFFFFFF), PixelShaderCache::GetClearProgram(), VertexShaderCache::GetClearVertexShader());
 935         if (zEnable)
 936                 D3D::RefreshRenderState(D3DRS_ZFUNC);
 937         D3D::RefreshRenderState(D3DRS_ALPHABLENDENABLE);
 938         UpdateViewport();
 939         SetScissorRect();
 940 }
 941
 942 void Renderer::SetBlendMode(bool forceUpdate)
 943 {
 944         if (bpmem.blendmode.logicopenable)
 945                 return;
 946
 947         if (bpmem.blendmode.subtract && bpmem.blendmode.blendenable)
 948         {
 949                 D3D::SetRenderState(D3DRS_ALPHABLENDENABLE, true);
 950                 D3D::SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_REVSUBTRACT);
 951                 D3D::SetRenderState(D3DRS_SRCBLEND, d3dSrcFactors[1]);
 952                 D3D::SetRenderState(D3DRS_DESTBLEND, d3dDestFactors[1]);
 953         }
 954         else
 955         {
 956                 D3D::SetRenderState(D3DRS_ALPHABLENDENABLE, bpmem.blendmode.blendenable && (!( bpmem.blendmode.srcfactor == 1 && bpmem.blendmode.dstfactor == 0)));
 957                 if (bpmem.blendmode.blendenable && (!( bpmem.blendmode.srcfactor == 1 && bpmem.blendmode.dstfactor == 0)))
 958                 {
 959                         D3D::SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
 960                         D3D::SetRenderState(D3DRS_SRCBLEND, d3dSrcFactors[bpmem.blendmode.srcfactor]);
 961                         D3D::SetRenderState(D3DRS_DESTBLEND, d3dDestFactors[bpmem.blendmode.dstfactor]);
 962                 }
 963         }
 964 }
 965
 966
 967
 968 void Renderer::Swap(u32 xfbAddr, FieldType field, u32 fbWidth, u32 fbHeight,const EFBRectangle& rc)
 969 {
 970         if (g_bSkipCurrentFrame || (!XFBWrited && !g_ActiveConfig.bUseRealXFB) || !fbWidth || !fbHeight)
 971         {
 972                 g_VideoInitialize.pCopiedToXFB(false);
 973                 return;
 974         }
 975         // this function is called after the XFB field is changed, not after
 976         // EFB is copied to XFB. In this way, flickering is reduced in games
 977         // and seems to also give more FPS in ZTP
 978
 979         if (field == FIELD_LOWER) xfbAddr -= fbWidth * 2;
 980         u32 xfbCount = 0;
 981         const XFBSource** xfbSourceList = FBManager.GetXFBSource(xfbAddr, fbWidth, fbHeight, xfbCount);
 982         if ((!xfbSourceList || xfbCount == 0) && g_ActiveConfig.bUseXFB && !g_ActiveConfig.bUseRealXFB)
 983         {
 984                 g_VideoInitialize.pCopiedToXFB(false);
 985                 return;
 986         }
 987
 988         Renderer::ResetAPIState();
 989         // Set the backbuffer as the rendering target
 990         D3D::dev->SetDepthStencilSurface(NULL);
 991         D3D::dev->SetRenderTarget(0, D3D::GetBackBufferSurface());
 992
 993         TargetRectangle dst_rect;
 994         ComputeDrawRectangle(s_backbuffer_width, s_backbuffer_height, false, &dst_rect);
 995         D3DVIEWPORT9 vp;
 996         vp.X = 0;
 997         vp.Y = 0;
 998         vp.Width  = s_backbuffer_width;
 999         vp.Height = s_backbuffer_height;
1000         vp.MinZ = 0.0f;
1001         vp.MaxZ = 1.0f;
1002         D3D::dev->SetViewport(&vp);
1003         D3D::dev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
1004
1005         int X = dst_rect.left;
1006         int Y = dst_rect.top;
1007         int Width  = dst_rect.right - dst_rect.left;
1008         int Height = dst_rect.bottom - dst_rect.top;
1009
1010         if (X < 0) X = 0;
1011         if (Y < 0) Y = 0;
1012         if (X > s_backbuffer_width) X = s_backbuffer_width;
1013         if (Y > s_backbuffer_height) Y = s_backbuffer_height;
1014         if (Width < 0) Width = 0;
1015         if (Height < 0) Height = 0;
1016         if (Width > (s_backbuffer_width - X)) Width = s_backbuffer_width - X;
1017         if (Height > (s_backbuffer_height - Y)) Height = s_backbuffer_height - Y;
1018         vp.X = X;
1019         vp.Y = Y;
1020         vp.Width = Width;
1021         vp.Height = Height;
1022         vp.MinZ = 0.0f;
1023         vp.MaxZ = 1.0f;
1024
1025         D3D::dev->SetViewport(&vp);
1026
1027         D3D::ChangeSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
1028         D3D::ChangeSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
1029
1030         if(g_ActiveConfig.bUseXFB)
1031         {
1032                 const XFBSource* xfbSource;
1033
1034                 // draw each xfb source
1035                 for (u32 i = 0; i < xfbCount; ++i)
1036                 {
1037                         xfbSource = xfbSourceList[i];
1038                         MathUtil::Rectangle<float> sourceRc;
1039
1040                         sourceRc.left = 0;
1041                         sourceRc.top = 0;
1042                         sourceRc.right = xfbSource->texWidth;
1043                         sourceRc.bottom = xfbSource->texHeight;
1044
1045                         MathUtil::Rectangle<float> drawRc;
1046
1047                         if (g_ActiveConfig.bUseXFB && !g_ActiveConfig.bUseRealXFB)
1048                         {
1049                                 // use virtual xfb with offset
1050                                 int xfbHeight = xfbSource->srcHeight;
1051                                 int xfbWidth = xfbSource->srcWidth;
1052                                 int hOffset = ((s32)xfbSource->srcAddr - (s32)xfbAddr) / ((s32)fbWidth * 2);
1053
1054                                 drawRc.bottom = 1.0f - 2.0f * ((hOffset) / (float)fbHeight);
1055                                 drawRc.top = 1.0f - 2.0f * ((hOffset + xfbHeight) / (float)fbHeight);
1056                                 drawRc.left = -(xfbWidth / (float)fbWidth);
1057                                 drawRc.right = (xfbWidth / (float)fbWidth);
1058
1059
1060                                 if (!g_ActiveConfig.bAutoScale)
1061                                 {
1062                                         // scale draw area for a 1 to 1 pixel mapping with the draw target
1063                                         float vScale = (float)fbHeight / (float)s_backbuffer_height;
1064                                         float hScale = (float)fbWidth / (float)s_backbuffer_width;
1065
1066                                         drawRc.top *= vScale;
1067                                         drawRc.bottom *= vScale;
1068                                         drawRc.left *= hScale;
1069                                         drawRc.right *= hScale;
1070                                 }
1071                         }
1072                         else
1073                         {
1074                                 drawRc.top = -1;
1075                                 drawRc.bottom = 1;
1076                                 drawRc.left = -1;
1077                                 drawRc.right = 1;
1078                         }
1079
1080                         D3D::drawShadedTexSubQuad(xfbSource->texture,&sourceRc,xfbSource->texWidth,xfbSource->texHeight,&drawRc,Width,Height,PixelShaderCache::GetColorCopyProgram(0),VertexShaderCache::GetSimpleVertexShader(0));
1081                 }
1082         }
1083         else
1084         {
1085                 TargetRectangle targetRc = Renderer::ConvertEFBRectangle(rc);
1086                 LPDIRECT3DTEXTURE9 read_texture = FBManager.GetEFBColorTexture(rc);
1087                 D3D::drawShadedTexQuad(read_texture,targetRc.AsRECT(),Renderer::GetFullTargetWidth(),Renderer::GetFullTargetHeight(),Width,Height,PixelShaderCache::GetColorCopyProgram(g_Config.iMultisampleMode),VertexShaderCache::GetSimpleVertexShader(g_Config.iMultisampleMode));
1088         }
1089         D3D::RefreshSamplerState(0, D3DSAMP_MINFILTER);
1090         D3D::RefreshSamplerState(0, D3DSAMP_MAGFILTER);
1091         vp.X = 0;
1092         vp.Y = 0;
1093         vp.Width  = s_backbuffer_width;
1094         vp.Height = s_backbuffer_height;
1095         vp.MinZ = 0.0f;
1096         vp.MaxZ = 1.0f;
1097         D3D::dev->SetViewport(&vp);
1098         if(s_bScreenshot)
1099         {
1100                 s_criticalScreenshot.Enter();
1101                 HRESULT hr = D3D::dev->GetRenderTargetData(D3D::GetBackBufferSurface(),ScreenShootMEMSurface);//, NULL, dst_rect.AsRECT(), D3D::GetBackBufferSurface(), NULL, dst_rect.AsRECT(), D3DX_FILTER_NONE, 0);
1102                 if(FAILED(hr))
1103                 {
1104                         PanicAlert("Error dumping surface data.");
1105                 }
1106                 hr = D3DXSaveSurfaceToFileA(s_sScreenshotName, D3DXIFF_PNG, ScreenShootMEMSurface, NULL, dst_rect.AsRECT());
1107                 if(FAILED(hr))
1108                 {
1109                         PanicAlert("Error saving screen.");
1110                 }
1111                 s_bScreenshot = false;
1112                 s_criticalScreenshot.Leave();
1113         }
1114         if (g_ActiveConfig.bDumpFrames)
1115         {
1116                 HRESULT hr = D3D::dev->GetRenderTargetData(D3D::GetBackBufferSurface(),ScreenShootMEMSurface);
1117                 if (!s_LastFrameDumped)
1118                 {
1119                         s_recordWidth = dst_rect.GetWidth();
1120                         s_recordHeight = dst_rect.GetHeight();
1121                         s_AVIDumping = AVIDump::Start(EmuWindow::GetParentWnd(), s_recordWidth, s_recordHeight);
1122                         if (!s_AVIDumping)
1123                         {
1124                                 PanicAlert("Error dumping frames to AVI.");
1125                         }
1126                         else
1127                         {
1128                                 char msg [255];
1129                                 sprintf_s(msg,255, "Dumping Frames to \"%sframedump0.avi\" (%dx%d RGB24)", File::GetUserPath(D_DUMPFRAMES_IDX), s_recordWidth, s_recordHeight);
1130                                 OSD::AddMessage(msg, 2000);
1131                         }
1132                 }
1133                 if (s_AVIDumping)
1134                 {
1135                         D3DLOCKED_RECT rect;
1136                         if (SUCCEEDED(ScreenShootMEMSurface->LockRect(&rect, dst_rect.AsRECT(), D3DLOCK_NO_DIRTY_UPDATE | D3DLOCK_NOSYSLOCK | D3DLOCK_READONLY)))
1137                         {
1138                                 char* data = (char*)malloc(3 * s_recordWidth * s_recordHeight);
1139                                 formatBufferDump((const char*)rect.pBits, data, s_recordWidth, s_recordHeight, rect.Pitch);
1140                                 AVIDump::AddFrame(data);
1141                                 free(data);
1142                                 ScreenShootMEMSurface->UnlockRect();
1143                         }
1144                 }
1145                 s_LastFrameDumped = true;
1146         }
1147         else
1148         {
1149                 if (s_LastFrameDumped && s_AVIDumping)
1150                 {
1151                         AVIDump::Stop();
1152                         s_AVIDumping = false;
1153                 }
1154                 s_LastFrameDumped = false;
1155         }
1156
1157         // Finish up the current frame, print some stats
1158         if (g_ActiveConfig.bShowFPS)
1159         {
1160                 char fps[20];
1161                 StringCchPrintfA(fps, 20, "FPS: %d\n", s_fps);
1162                 D3D::font.DrawTextScaled(0, 30, 20, 20, 0.0f, 0xFF00FFFF, fps, false);
1163         }
1164         Renderer::DrawDebugText();
1165
1166         if (g_ActiveConfig.bOverlayStats)
1167         {
1168                 Statistics::ToString(st);
1169                 D3D::font.DrawTextScaled(0, 30, 20, 20, 0.0f, 0xFF00FFFF, st, false);
1170         }
1171         else if (g_ActiveConfig.bOverlayProjStats)
1172         {
1173                 Statistics::ToStringProj(st);
1174                 D3D::font.DrawTextScaled(0, 30, 20, 20, 0.0f, 0xFF00FFFF, st, false);
1175         }
1176
1177
1178         OSD::DrawMessages();
1179
1180         D3D::EndFrame();
1181
1182         frameCount++;
1183         TextureCache::Cleanup();
1184
1185         // Make any new configuration settings active.
1186         UpdateActiveConfig();
1187         WindowResized = false;
1188         CheckForResize();
1189
1190         bool xfbchanged = false;
1191
1192         if (s_XFB_width != fbWidth || s_XFB_height != fbHeight)
1193         {
1194                 xfbchanged = true;
1195                 s_XFB_width = fbWidth;
1196                 s_XFB_height = fbHeight;
1197                 if (s_XFB_width < 1) s_XFB_width = MAX_XFB_WIDTH;
1198                 if (s_XFB_width > MAX_XFB_WIDTH) s_XFB_width = MAX_XFB_WIDTH;
1199                 if (s_XFB_height < 1) s_XFB_height = MAX_XFB_HEIGHT;
1200                 if (s_XFB_height > MAX_XFB_HEIGHT) s_XFB_height = MAX_XFB_HEIGHT;
1201         }
1202
1203         u32 newAA = g_ActiveConfig.iMultisampleMode;
1204         u32 newEFBScale = g_ActiveConfig.iEFBScale;
1205         if (newAA != s_LastAA || newEFBScale != s_LastEFBScale || xfbchanged || WindowResized)
1206         {
1207                 s_LastAA = newAA;
1208                 s_LastEFBScale = newEFBScale;
1209
1210                 ComputeDrawRectangle(s_backbuffer_width, s_backbuffer_height, false, &dst_rect);
1211
1212                 if(g_ActiveConfig.bUseRealXFB)
1213                 {
1214                         xScale = yScale = 1.0f;
1215                 }
1216                 else
1217                 {
1218                         xScale = (float)(dst_rect.right - dst_rect.left) / (float)s_XFB_width;
1219                         yScale = (float)(dst_rect.bottom - dst_rect.top) / (float)s_XFB_height;
1220                 }
1221
1222                 float SupersampleCoeficient = s_LastAA + 1;
1223                 switch(s_LastEFBScale)
1224                 {
1225                         case 0:
1226                                 EFBxScale = xScale;
1227                                 EFByScale = yScale;
1228                                 break;
1229                         case 1:
1230                                 EFBxScale = ceilf(xScale);
1231                                 EFByScale = ceilf(yScale);
1232                                 break;
1233                         default:
1234                                 EFBxScale = g_ActiveConfig.iEFBScale - 1;
1235                                 EFByScale = EFBxScale;
1236                                 break;
1237                 };
1238
1239                 EFBxScale *= SupersampleCoeficient;
1240                 EFByScale *= SupersampleCoeficient;
1241                 s_target_width  = EFB_WIDTH * EFBxScale;
1242                 s_target_height = EFB_HEIGHT * EFByScale;
1243                 D3D::dev->SetRenderTarget(0, D3D::GetBackBufferSurface());
1244                 D3D::dev->SetDepthStencilSurface(D3D::GetBackBufferDepthSurface());
1245                 if (WindowResized)
1246                 {
1247                         SetupDeviceObjects();
1248                 }
1249                 else
1250                 {
1251                         FBManager.Destroy();
1252                         FBManager.Create();
1253                 }
1254                 D3D::dev->SetRenderTarget(0, FBManager.GetEFBColorRTSurface());
1255                 D3D::dev->SetDepthStencilSurface(FBManager.GetEFBDepthRTSurface());
1256         }
1257
1258         // ---------------------------------------------------------------------
1259         // Count FPS.
1260         // -------------
1261         static int fpscount = 1;
1262         static unsigned long lasttime;
1263         if (XFBWrited)
1264                 ++fpscount;
1265         if (Common::Timer::GetTimeMs() - lasttime > 1000)
1266         {
1267                 lasttime = Common::Timer::GetTimeMs();
1268                 s_fps = fpscount - 1;
1269                 fpscount = 1;
1270         }
1271
1272         // Begin new frame
1273         // Set default viewport and scissor, for the clear to work correctly
1274         stats.ResetFrame();
1275
1276         // Flip/present backbuffer to frontbuffer here
1277         D3D::Present();
1278         D3D::BeginFrame();
1279         Renderer::RestoreAPIState();
1280         D3D::dev->SetRenderTarget(0, FBManager.GetEFBColorRTSurface());
1281         D3D::dev->SetDepthStencilSurface(FBManager.GetEFBDepthRTSurface());
1282         UpdateViewport();
1283         VertexShaderManager::SetViewportChanged();
1284         g_VideoInitialize.pCopiedToXFB(XFBWrited || g_ActiveConfig.bUseRealXFB);
1285         XFBWrited = false;
1286 }
1287
1288 void Renderer::ResetAPIState()
1289 {
1290         D3D::SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
1291         D3D::SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
1292         D3D::SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
1293         D3D::SetRenderState(D3DRS_ZENABLE, FALSE);
1294         D3D::SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
1295         DWORD color_mask = D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE;
1296         D3D::SetRenderState(D3DRS_COLORWRITEENABLE, color_mask);
1297 }
1298
1299 void Renderer::RestoreAPIState()
1300 {
1301         // Gets us back into a more game-like state.
1302         D3D::SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
1303         UpdateViewport();
1304         SetScissorRect();
1305         if (bpmem.zmode.testenable)
1306                 D3D::SetRenderState(D3DRS_ZENABLE, TRUE);
1307         if (bpmem.zmode.updateenable)
1308                 D3D::SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
1309         SetColorMask();
1310         SetLogicOpMode();
1311 }
1312
1313 void Renderer::SetGenerationMode()
1314 {
1315         D3D::SetRenderState(D3DRS_CULLMODE, d3dCullModes[bpmem.genMode.cullmode]);
1316 }
1317
1318 void Renderer::SetDepthMode()
1319 {
1320         if (bpmem.zmode.testenable)
1321         {
1322                 D3D::SetRenderState(D3DRS_ZENABLE, TRUE);
1323                 D3D::SetRenderState(D3DRS_ZWRITEENABLE, bpmem.zmode.updateenable);
1324                 D3D::SetRenderState(D3DRS_ZFUNC, d3dCmpFuncs[bpmem.zmode.func]);
1325         }
1326         else
1327         {
1328                 D3D::SetRenderState(D3DRS_ZENABLE, FALSE);
1329                 D3D::SetRenderState(D3DRS_ZWRITEENABLE, FALSE);  // ??
1330         }
1331 }
1332
1333 void Renderer::SetLogicOpMode()
1334 {
1335         if (bpmem.blendmode.logicopenable && bpmem.blendmode.logicmode != 3)
1336         {
1337                 D3D::SetRenderState(D3DRS_ALPHABLENDENABLE, true);
1338                 D3D::SetRenderState(D3DRS_BLENDOP, d3dLogicOpop[bpmem.blendmode.logicmode]);
1339                 D3D::SetRenderState(D3DRS_SRCBLEND, d3dLogicOpSrcFactors[bpmem.blendmode.logicmode]);
1340                 D3D::SetRenderState(D3DRS_DESTBLEND, d3dLogicOpDestFactors[bpmem.blendmode.logicmode]);
1341         }
1342         else
1343         {
1344                 SetBlendMode(true);
1345         }
1346 }
1347
1348 void Renderer::SetDitherMode()
1349 {
1350         D3D::SetRenderState(D3DRS_DITHERENABLE, bpmem.blendmode.dither);
1351 }
1352
1353 void Renderer::SetLineWidth()
1354 {
1355         // We can't change line width in D3D unless we use ID3DXLine
1356         float fratio = xfregs.rawViewport[0] != 0 ? Renderer::GetTargetScaleX() : 1.0f;
1357         float psize = bpmem.lineptwidth.linesize * fratio / 6.0f;
1358         D3D::SetRenderState(D3DRS_POINTSIZE, *((DWORD*)&psize));
1359 }
1360
1361 void Renderer::SetSamplerState(int stage, int texindex)
1362 {
1363         const FourTexUnits &tex = bpmem.tex[texindex];
1364         const TexMode0 &tm0 = tex.texMode0[stage];
1365         const TexMode1 &tm1 = tex.texMode1[stage];
1366
1367         D3DTEXTUREFILTERTYPE min, mag, mip;
1368         if (g_ActiveConfig.bForceFiltering)
1369         {
1370                 min = mag = mip = D3DTEXF_LINEAR;
1371         }
1372         else
1373         {
1374                 min = (tm0.min_filter & 4) ? D3DTEXF_LINEAR : D3DTEXF_POINT;
1375                 mag = tm0.mag_filter ? D3DTEXF_LINEAR : D3DTEXF_POINT;
1376                 mip = (tm0.min_filter == 8) ? D3DTEXF_NONE : d3dMipFilters[tm0.min_filter & 3];
1377                 if((tm0.min_filter & 3) && (tm0.min_filter != 8) && ((tm1.max_lod >> 4) == 0))
1378                         mip = D3DTEXF_NONE;
1379         }
1380         if (texindex)
1381                 stage += 4;
1382
1383         if (mag == D3DTEXF_LINEAR && min == D3DTEXF_LINEAR && g_ActiveConfig.iMaxAnisotropy > 1)
1384         {
1385                 min = D3DTEXF_ANISOTROPIC;
1386         }
1387         D3D::SetSamplerState(stage, D3DSAMP_MINFILTER, min);
1388         D3D::SetSamplerState(stage, D3DSAMP_MAGFILTER, mag);
1389         D3D::SetSamplerState(stage, D3DSAMP_MIPFILTER, mip);
1390
1391         D3D::SetSamplerState(stage, D3DSAMP_ADDRESSU, d3dClamps[tm0.wrap_s]);
1392         D3D::SetSamplerState(stage, D3DSAMP_ADDRESSV, d3dClamps[tm0.wrap_t]);
1393         //float SuperSampleCoeficient = (s_LastAA < 3)? s_LastAA + 1 : s_LastAA - 1;// uncoment this changes to conserve detail when incresing ssaa level
1394         float lodbias = (tm0.lod_bias / 32.0f);// + (s_LastAA)?(log(SuperSampleCoeficient) / log(2.0f)):0;
1395         D3D::SetSamplerState(stage, D3DSAMP_MIPMAPLODBIAS, *(DWORD*)&lodbias);
1396         D3D::SetSamplerState(stage, D3DSAMP_MAXMIPLEVEL, tm1.min_lod >> 4);
1397 }
1398
1399 void Renderer::SetInterlacingMode()
1400 {
1401         // TODO
1402 }
1403
1404 // Save screenshot
1405 void Renderer::SetScreenshot(const char *filename)
1406 {
1407         s_criticalScreenshot.Enter();
1408         strcpy_s(s_sScreenshotName, filename);
1409         s_bScreenshot = true;
1410         s_criticalScreenshot.Leave();
1411 }