Source/Plugins/Plugin_VideoDX9/Src/D3DBase.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 "D3DBase.h"
  19 #include "VideoConfig.h"
  20 #include "Render.h"
  21 #include "XFStructs.h"
  22
  23 namespace D3D
  24 {
  25
  26 LPDIRECT3D9        D3D = NULL; // Used to create the D3DDevice
  27 LPDIRECT3DDEVICE9  dev = NULL; // Our rendering device
  28 LPDIRECT3DSURFACE9 back_buffer;
  29 LPDIRECT3DSURFACE9 back_buffer_z;
  30 D3DCAPS9 caps;
  31 HWND hWnd;
  32
  33 static int multisample;
  34 static int resolution;
  35 static int xres, yres;
  36 static bool auto_depth_stencil = false;
  37
  38 #define VENDOR_NVIDIA 4318
  39 #define VENDOR_ATI    4098
  40
  41 bool bFrameInProgress = false;
  42
  43 #define MAX_ADAPTERS 4
  44 static Adapter adapters[MAX_ADAPTERS];
  45 static int numAdapters;
  46 static int cur_adapter;
  47
  48 // Value caches for state filtering
  49 const int MaxTextureStages = 9;
  50 const int MaxRenderStates = 210 + 46;
  51 const int MaxTextureTypes = 33;
  52 const int MaxSamplerSize = 13;
  53 const int MaxSamplerTypes = 15;
  54 static bool m_RenderStatesSet[MaxRenderStates];
  55 static DWORD m_RenderStates[MaxRenderStates];
  56 static bool m_RenderStatesChanged[MaxRenderStates];
  57
  58 static DWORD m_TextureStageStates[MaxTextureStages][MaxTextureTypes];
  59 static bool m_TextureStageStatesSet[MaxTextureStages][MaxTextureTypes];
  60 static bool m_TextureStageStatesChanged[MaxTextureStages][MaxTextureTypes];
  61
  62 static DWORD m_SamplerStates[MaxSamplerSize][MaxSamplerTypes];
  63 static bool m_SamplerStatesSet[MaxSamplerSize][MaxSamplerTypes];
  64 static bool m_SamplerStatesChanged[MaxSamplerSize][MaxSamplerTypes];
  65
  66 LPDIRECT3DBASETEXTURE9 m_Textures[16];
  67 LPDIRECT3DVERTEXDECLARATION9 m_VtxDecl;
  68 LPDIRECT3DPIXELSHADER9 m_PixelShader;
  69 LPDIRECT3DVERTEXSHADER9 m_VertexShader;
  70
  71 void Enumerate();
  72
  73 int GetNumAdapters() { return numAdapters; }
  74 const Adapter &GetAdapter(int i) { return adapters[i]; }
  75 const Adapter &GetCurAdapter() { return adapters[cur_adapter]; }
  76
  77 bool IsATIDevice()
  78 {
  79         return GetCurAdapter().ident.VendorId == VENDOR_ATI;
  80 }
  81
  82
  83 HRESULT Init()
  84 {
  85         // Create the D3D object, which is needed to create the D3DDevice.
  86         D3D = Direct3DCreate9(D3D_SDK_VERSION);
  87         if (!D3D)
  88                 return E_FAIL;
  89         Enumerate();
  90         return S_OK;
  91 }
  92
  93 void Shutdown()
  94 {
  95         D3D->Release();
  96         D3D = 0;
  97 }
  98
  99 void EnableAlphaToCoverage()
 100 {
 101         // Each vendor has their own specific little hack.
 102         if (GetCurAdapter().ident.VendorId == VENDOR_ATI)
 103                 D3D::SetRenderState(D3DRS_POINTSIZE, (D3DFORMAT)MAKEFOURCC('A', '2', 'M', '1'));
 104         else
 105                 D3D::SetRenderState(D3DRS_ADAPTIVETESS_Y, (D3DFORMAT)MAKEFOURCC('A', 'T', 'O', 'C'));
 106 }
 107
 108 void InitPP(int adapter, int f, int aa_mode, D3DPRESENT_PARAMETERS *pp)
 109 {
 110         ZeroMemory(pp, sizeof(D3DPRESENT_PARAMETERS));
 111         pp->hDeviceWindow = hWnd;
 112         if (auto_depth_stencil)
 113         {
 114                 pp->EnableAutoDepthStencil = TRUE;
 115                 pp->AutoDepthStencilFormat = D3DFMT_D24S8;
 116         } else {
 117                 pp->EnableAutoDepthStencil = FALSE;
 118                 pp->AutoDepthStencilFormat = D3DFMT_UNKNOWN;
 119         }
 120         pp->BackBufferFormat = D3DFMT_A8R8G8B8;
 121         if (aa_mode >= (int)adapters[adapter].aa_levels.size())
 122                 aa_mode = 0;
 123
 124         pp->MultiSampleType = adapters[adapter].aa_levels[aa_mode].ms_setting;
 125         pp->MultiSampleQuality = adapters[adapter].aa_levels[aa_mode].qual_setting;
 126
 127         pp->Flags = auto_depth_stencil ? D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL : 0;
 128
 129         RECT client;
 130         GetClientRect(hWnd, &client);
 131         xres = pp->BackBufferWidth  = client.right - client.left;
 132         yres = pp->BackBufferHeight = client.bottom - client.top;
 133         pp->SwapEffect = D3DSWAPEFFECT_DISCARD;
 134         pp->PresentationInterval = g_Config.bVSync ? D3DPRESENT_INTERVAL_DEFAULT : D3DPRESENT_INTERVAL_IMMEDIATE;
 135         pp->Windowed = TRUE;
 136 }
 137
 138 void Enumerate()
 139 {
 140         numAdapters = D3D::D3D->GetAdapterCount();
 141
 142         for (int i = 0; i < std::min(MAX_ADAPTERS, numAdapters); i++)
 143         {
 144                 Adapter &a = adapters[i];
 145                 a.aa_levels.clear();
 146                 a.resolutions.clear();
 147                 D3D::D3D->GetAdapterIdentifier(i, 0, &a.ident);
 148                 bool isNvidia = a.ident.VendorId == VENDOR_NVIDIA;
 149
 150                 // Add SuperSamples modes
 151                 a.aa_levels.push_back(AALevel("None", D3DMULTISAMPLE_NONE, 0));
 152                 a.aa_levels.push_back(AALevel("2.25x SSAA", D3DMULTISAMPLE_NONE, 0));
 153                 a.aa_levels.push_back(AALevel("4x SSAA", D3DMULTISAMPLE_NONE, 0));
 154                 a.aa_levels.push_back(AALevel("9x SSAA", D3DMULTISAMPLE_NONE, 0));
 155                 //Add multisample modes
 156                 //disable them will they are not implemnted
 157                 /*
 158                 DWORD qlevels = 0;
 159                 if (D3DERR_NOTAVAILABLE != D3D::D3D->CheckDeviceMultiSampleType(
 160                         i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, TRUE, D3DMULTISAMPLE_2_SAMPLES, &qlevels))
 161                         if (qlevels > 0)
 162                                 a.aa_levels.push_back(AALevel("2x MSAA", D3DMULTISAMPLE_2_SAMPLES, 0));
 163
 164                 if (D3DERR_NOTAVAILABLE != D3D::D3D->CheckDeviceMultiSampleType(
 165                         i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, TRUE, D3DMULTISAMPLE_2_SAMPLES, &qlevels))
 166                         if (qlevels > 0)
 167                                 a.aa_levels.push_back(AALevel("4x MSAA", D3DMULTISAMPLE_4_SAMPLES, 0));
 168
 169                 if (D3DERR_NOTAVAILABLE != D3D::D3D->CheckDeviceMultiSampleType(
 170                         i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, TRUE, D3DMULTISAMPLE_8_SAMPLES, &qlevels))
 171                         if (qlevels > 0)
 172                                 a.aa_levels.push_back(AALevel("8x MSAA", D3DMULTISAMPLE_8_SAMPLES, 0));
 173
 174                 if (isNvidia)
 175                 {
 176                         // CSAA support
 177                         if (D3DERR_NOTAVAILABLE != D3D::D3D->CheckDeviceMultiSampleType(
 178                                 i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, TRUE, D3DMULTISAMPLE_4_SAMPLES, &qlevels))
 179                         {
 180                                 if (qlevels > 2)
 181                                 {
 182                                         // 8x, 8xQ are available
 183                                         // See http://developer.nvidia.com/object/coverage-sampled-aa.html
 184                                         a.aa_levels.push_back(AALevel("8x CSAA", D3DMULTISAMPLE_4_SAMPLES, 2));
 185                                         a.aa_levels.push_back(AALevel("8xQ CSAA", D3DMULTISAMPLE_8_SAMPLES, 0));
 186                                 }
 187                         }
 188                         if (D3DERR_NOTAVAILABLE != D3D::D3D->CheckDeviceMultiSampleType(
 189                                 i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, TRUE, D3DMULTISAMPLE_8_SAMPLES, &qlevels))
 190                         {
 191                                 if (qlevels > 2)
 192                                 {
 193                                         // 16x, 16xQ are available
 194                                         // See http://developer.nvidia.com/object/coverage-sampled-aa.html
 195                                         a.aa_levels.push_back(AALevel("16x CSAA", D3DMULTISAMPLE_4_SAMPLES, 4));
 196                                         a.aa_levels.push_back(AALevel("16xQ CSAA", D3DMULTISAMPLE_8_SAMPLES, 2));
 197                                 }
 198                         }
 199                 }
 200                 */
 201                 // Determine if INTZ is supported. Code from ATI's doc.
 202                 // http://developer.amd.com/gpu_assets/Advanced%20DX9%20Capabilities%20for%20ATI%20Radeon%20Cards.pdf
 203                 a.supports_intz = D3D_OK == D3D->CheckDeviceFormat(
 204                         i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
 205                         D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_TEXTURE, FOURCC_INTZ);
 206                 // Also check for RAWZ (nvidia only, but the only option to get Z24 textures on sub GF8800
 207                 a.supports_rawz = D3D_OK == D3D->CheckDeviceFormat(
 208                         i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
 209                         D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_TEXTURE, FOURCC_RAWZ);
 210                 // Might as well check for RESZ and NULL too.
 211                 a.supports_resz = D3D_OK == D3D->CheckDeviceFormat(
 212                         i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
 213                         D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_TEXTURE, FOURCC_RESZ);
 214                 a.supports_null = D3D_OK == D3D->CheckDeviceFormat(
 215                         i, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
 216                         D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_TEXTURE, FOURCC_NULL);
 217
 218                 if (a.aa_levels.size() == 1)
 219                 {
 220                         strcpy(a.aa_levels[0].name, "(Not supported on this device)");
 221                 }
 222                 int numModes = D3D::D3D->GetAdapterModeCount(i, D3DFMT_X8R8G8B8);
 223                 for (int m = 0; m < numModes; m++)
 224                 {
 225                         D3DDISPLAYMODE mode;
 226                         D3D::D3D->EnumAdapterModes(i, D3DFMT_X8R8G8B8, m, &mode);
 227
 228                         int found = -1;
 229                         for (int x = 0; x < (int)a.resolutions.size(); x++)
 230                         {
 231                                 if (a.resolutions[x].xres == mode.Width && a.resolutions[x].yres == mode.Height)
 232                                 {
 233                                         found = x;
 234                                         break;
 235                                 }
 236                         }
 237
 238                         Resolution temp;
 239                         Resolution &r = found==-1 ? temp : a.resolutions[found];
 240
 241                         sprintf(r.name, "%ix%i", mode.Width, mode.Height);
 242                         r.bitdepths.insert(mode.Format);
 243                         r.refreshes.insert(mode.RefreshRate);
 244                         if (found == -1 && mode.Width >= 640 && mode.Height >= 480)
 245                         {
 246                                 r.xres = mode.Width;
 247                                 r.yres = mode.Height;
 248                                 a.resolutions.push_back(r);
 249                         }
 250                 }
 251         }
 252 }
 253
 254 HRESULT Create(int adapter, HWND wnd, int _resolution, int aa_mode, bool auto_depth)
 255 {
 256         hWnd = wnd;
 257         multisample = aa_mode;
 258         resolution = _resolution;
 259         auto_depth_stencil = auto_depth;
 260         cur_adapter = adapter;
 261         D3DPRESENT_PARAMETERS d3dpp;
 262         InitPP(adapter, resolution, aa_mode, &d3dpp);
 263
 264         if (FAILED(D3D->CreateDevice(
 265                 adapter,
 266                 D3DDEVTYPE_HAL,
 267                 wnd,
 268                 D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE,  //doesn't seem to make a difference
 269                 &d3dpp, &dev)))
 270         {
 271                 if (FAILED(D3D->CreateDevice(
 272                         adapter,
 273                         D3DDEVTYPE_HAL,
 274                         wnd,
 275                         D3DCREATE_SOFTWARE_VERTEXPROCESSING,
 276                         &d3dpp, &dev)))
 277                 {
 278                         MessageBox(wnd,
 279                                 _T("Failed to initialize Direct3D."),
 280                                 _T("Dolphin Direct3D plugin"), MB_OK | MB_ICONERROR);
 281                         return E_FAIL;
 282                 }
 283         }
 284
 285         dev->GetDeviceCaps(&caps);
 286         dev->GetRenderTarget(0, &back_buffer);
 287         if (dev->GetDepthStencilSurface(&back_buffer_z) == D3DERR_NOTFOUND)
 288                 back_buffer_z = NULL;
 289         D3D::SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE );
 290         D3D::SetRenderState(D3DRS_FILLMODE, g_Config.bWireFrame ? D3DFILL_WIREFRAME : D3DFILL_SOLID);
 291         memset(m_Textures, 0, sizeof(m_Textures));
 292         memset(m_TextureStageStatesSet, 0, sizeof(m_TextureStageStatesSet));
 293         memset(m_RenderStatesSet, 0, sizeof(m_RenderStatesSet));
 294         memset(m_SamplerStatesSet, 0, sizeof(m_SamplerStatesSet));
 295         memset(m_TextureStageStatesChanged, 0, sizeof(m_TextureStageStatesChanged));
 296         memset(m_RenderStatesChanged, 0, sizeof(m_RenderStatesChanged));
 297         memset(m_SamplerStatesChanged, 0, sizeof(m_SamplerStatesChanged));
 298         m_VtxDecl = NULL;
 299         m_PixelShader = NULL;
 300         m_VertexShader = NULL;
 301         // Device state would normally be set here
 302         return S_OK;
 303 }
 304
 305 void Close()
 306 {
 307         if (back_buffer_z)
 308                 back_buffer_z->Release();
 309         back_buffer_z = NULL;
 310         back_buffer->Release();
 311         back_buffer = NULL;
 312
 313         ULONG references = dev->Release();
 314         if (references)
 315                 ERROR_LOG(VIDEO, "Unreleased references: %i.", references);
 316
 317         dev = 0;
 318 }
 319
 320 const D3DCAPS9 &GetCaps()
 321 {
 322         return caps;
 323 }
 324
 325 const char *VertexShaderVersionString()
 326 {
 327         static const char *versions[5] = {"ERROR", "vs_1_4", "vs_2_0", "vs_3_0", "vs_4_0"};
 328         int version = ((D3D::caps.VertexShaderVersion >> 8) & 0xFF);
 329         return versions[std::min(4, version)];
 330 }
 331
 332 const char *PixelShaderVersionString()
 333 {
 334         static const char *versions[5] = {"ERROR", "ps_1_4", "ps_2_0", "ps_3_0", "ps_4_0"};
 335         int version = ((D3D::caps.PixelShaderVersion >> 8) & 0xFF);
 336         return versions[std::min(4, version)];
 337 }
 338
 339 LPDIRECT3DSURFACE9 GetBackBufferSurface()
 340 {
 341         return back_buffer;
 342 }
 343
 344 LPDIRECT3DSURFACE9 GetBackBufferDepthSurface()
 345 {
 346         return back_buffer_z;
 347 }
 348
 349 void ShowD3DError(HRESULT err)
 350 {
 351         switch (err)
 352         {
 353         case D3DERR_DEVICELOST: PanicAlert("Device Lost"); break;
 354         case D3DERR_INVALIDCALL: PanicAlert("Invalid Call"); break;
 355         case D3DERR_DRIVERINTERNALERROR: PanicAlert("Driver Internal Error"); break;
 356         case D3DERR_OUTOFVIDEOMEMORY: PanicAlert("Out of vid mem"); break;
 357         default:
 358                 // MessageBoxA(0,"Other error or success","ERROR",0);
 359                 break;
 360         }
 361 }
 362
 363 void Reset()
 364 {
 365         if (dev)
 366         {
 367                 // ForgetCachedState();
 368
 369                 // Can't keep a pointer around to the backbuffer surface when resetting.
 370                 if (back_buffer_z)
 371                         back_buffer_z->Release();
 372                 back_buffer_z = NULL;
 373                 back_buffer->Release();
 374                 back_buffer = NULL;
 375
 376                 D3DPRESENT_PARAMETERS d3dpp;
 377                 InitPP(cur_adapter, resolution, multisample, &d3dpp);
 378                 HRESULT hr = dev->Reset(&d3dpp);
 379                 ShowD3DError(hr);
 380
 381                 dev->GetRenderTarget(0, &back_buffer);
 382                 if (dev->GetDepthStencilSurface(&back_buffer_z) == D3DERR_NOTFOUND)
 383                         back_buffer_z = NULL;
 384                 ApplyCachedState();
 385         }
 386 }
 387
 388 int GetBackBufferWidth()
 389 {
 390         return xres;
 391 }
 392
 393 int GetBackBufferHeight()
 394 {
 395         return yres;
 396 }
 397
 398 bool BeginFrame()
 399 {
 400         if (bFrameInProgress)
 401         {
 402                 PanicAlert("BeginFrame WTF");
 403                 return false;
 404         }
 405         bFrameInProgress = true;
 406         if (dev)
 407         {
 408                 dev->BeginScene();
 409                 return true;
 410         }
 411         else
 412                 return false;
 413 }
 414
 415 void EndFrame()
 416 {
 417         if (!bFrameInProgress)
 418         {
 419                 PanicAlert("EndFrame WTF");
 420                 return;
 421         }
 422         bFrameInProgress = false;
 423         dev->EndScene();
 424 }
 425
 426 void Present()
 427 {
 428         if (dev)
 429         {
 430                 dev->Present(NULL, NULL, NULL, NULL);
 431         }
 432 }
 433
 434 void ApplyCachedState()
 435 {
 436         for (int sampler = 0; sampler < 8; sampler++)
 437         {
 438                 for (int type = 0; type < MaxSamplerTypes; type++)
 439                 {
 440                         if(m_SamplerStatesSet[sampler][type])
 441                                 D3D::dev->SetSamplerState(sampler, (D3DSAMPLERSTATETYPE)type, m_SamplerStates[sampler][type]);
 442                 }
 443         }
 444
 445         for (int rs = 0; rs < MaxRenderStates; rs++)
 446         {
 447                 if (m_RenderStatesSet[rs])
 448                         D3D::dev->SetRenderState((D3DRENDERSTATETYPE)rs, m_RenderStates[rs]);
 449         }
 450
 451         // We don't bother restoring these so let's just wipe the state copy
 452         // so no stale state is around.
 453         memset(m_Textures, 0, sizeof(m_Textures));
 454         memset(m_TextureStageStatesSet, 0, sizeof(m_TextureStageStatesSet));
 455         memset(m_TextureStageStatesChanged, 0, sizeof(m_TextureStageStatesChanged));
 456         m_VtxDecl = NULL;
 457         m_PixelShader = NULL;
 458         m_VertexShader = NULL;
 459 }
 460
 461 void SetTexture(DWORD Stage, LPDIRECT3DBASETEXTURE9 pTexture)
 462 {
 463         if (m_Textures[Stage] != pTexture)
 464         {
 465                 m_Textures[Stage] = pTexture;
 466                 D3D::dev->SetTexture(Stage, pTexture);
 467         }
 468 }
 469
 470 void RefreshRenderState(D3DRENDERSTATETYPE State)
 471 {
 472         if(m_RenderStatesSet[State] && m_RenderStatesChanged[State])
 473         {
 474                 D3D::dev->SetRenderState(State, m_RenderStates[State]);
 475                 m_RenderStatesChanged[State] = false;
 476         }
 477 }
 478
 479 void SetRenderState(D3DRENDERSTATETYPE State, DWORD Value)
 480 {
 481         if (m_RenderStates[State] != Value || !m_RenderStatesSet[State])
 482         {
 483                 m_RenderStates[State] = Value;
 484                 m_RenderStatesSet[State] = true;
 485                 m_RenderStatesChanged[State] = false;
 486                 D3D::dev->SetRenderState(State, Value);
 487         }
 488 }
 489
 490 void ChangeRenderState(D3DRENDERSTATETYPE State, DWORD Value)
 491 {
 492         if (m_RenderStates[State] != Value || !m_RenderStatesSet[State])
 493         {
 494                 m_RenderStatesChanged[State] = m_RenderStatesSet[State];
 495                 D3D::dev->SetRenderState(State, Value);
 496         }
 497         else
 498         {
 499                 m_RenderStatesChanged[State] = false;
 500         }
 501 }
 502
 503 void SetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value)
 504 {
 505         if (m_TextureStageStates[Stage][Type] != Value || !m_TextureStageStatesSet[Stage][Type])
 506         {
 507                 m_TextureStageStates[Stage][Type] = Value;
 508                 m_TextureStageStatesSet[Stage][Type]=true;
 509                 m_TextureStageStatesChanged[Stage][Type]=false;
 510                 D3D::dev->SetTextureStageState(Stage, Type, Value);
 511         }
 512 }
 513
 514 void RefreshTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type)
 515 {
 516         if(m_TextureStageStatesSet[Stage][Type] && m_TextureStageStatesChanged[Stage][Type])
 517         {
 518                 D3D::dev->SetTextureStageState(Stage, Type, m_TextureStageStates[Stage][Type]);
 519                 m_TextureStageStatesChanged[Stage][Type] = false;
 520         }
 521 }
 522
 523 void ChangeTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value)
 524 {
 525         if (m_TextureStageStates[Stage][Type] != Value || !m_TextureStageStatesSet[Stage][Type])
 526         {
 527                 m_TextureStageStatesChanged[Stage][Type] = m_TextureStageStatesSet[Stage][Type];
 528                 D3D::dev->SetTextureStageState(Stage, Type, Value);
 529         }
 530         else
 531         {
 532                 m_TextureStageStatesChanged[Stage][Type] = false;
 533         }
 534 }
 535
 536 void SetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value)
 537 {
 538         if (m_SamplerStates[Sampler][Type] != Value || !m_SamplerStatesSet[Sampler][Type])
 539         {
 540                 m_SamplerStates[Sampler][Type] = Value;
 541                 m_SamplerStatesSet[Sampler][Type] = true;
 542                 m_SamplerStatesChanged[Sampler][Type] = false;
 543                 D3D::dev->SetSamplerState(Sampler, Type, Value);
 544         }
 545 }
 546
 547 void RefreshSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type)
 548 {
 549         if(m_SamplerStatesSet[Sampler][Type] && m_SamplerStatesChanged[Sampler][Type])
 550         {
 551                 D3D::dev->SetSamplerState(Sampler, Type, m_SamplerStates[Sampler][Type]);
 552                 m_SamplerStatesChanged[Sampler][Type] = false;
 553         }
 554 }
 555
 556 void ChangeSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value)
 557 {
 558         if (m_SamplerStates[Sampler][Type] != Value || !m_SamplerStatesSet[Sampler][Type])
 559         {
 560                 m_SamplerStatesChanged[Sampler][Type] = m_SamplerStatesSet[Sampler][Type];
 561                 D3D::dev->SetSamplerState(Sampler, Type, Value);
 562         }
 563         else
 564         {
 565                 m_SamplerStatesChanged[Sampler][Type] = false;
 566         }
 567 }
 568
 569 void RefreshVertexDeclaration()
 570 {
 571         if (m_VtxDecl)
 572         {
 573                 D3D::dev->SetVertexDeclaration(m_VtxDecl);
 574         }
 575 }
 576
 577 void SetVertexDeclaration(LPDIRECT3DVERTEXDECLARATION9 decl)
 578 {
 579         if (!decl) {
 580                 m_VtxDecl = NULL;
 581                 return;
 582         }
 583         if (decl != m_VtxDecl)
 584         {
 585                 D3D::dev->SetVertexDeclaration(decl);
 586                 m_VtxDecl = decl;
 587         }
 588 }
 589
 590 void RefreshVertexShader()
 591 {
 592         if (m_VertexShader)
 593         {
 594                 D3D::dev->SetVertexShader(m_VertexShader);
 595         }
 596 }
 597
 598 void SetVertexShader(LPDIRECT3DVERTEXSHADER9 shader)
 599 {
 600         if (!shader) {
 601                 m_VertexShader = NULL;
 602                 return;
 603         }
 604         if (shader != m_VertexShader)
 605         {
 606                 D3D::dev->SetVertexShader(shader);
 607                 m_VertexShader = shader;
 608         }
 609 }
 610
 611 void RefreshPixelShader()
 612 {
 613         if (m_PixelShader)
 614         {
 615                 D3D::dev->SetPixelShader(m_PixelShader);
 616         }
 617 }
 618
 619 void SetPixelShader(LPDIRECT3DPIXELSHADER9 shader)
 620 {
 621         if (!shader) {
 622                 m_PixelShader = NULL;
 623                 return;
 624         }
 625         if (shader != m_PixelShader)
 626         {
 627                 D3D::dev->SetPixelShader(shader);
 628                 m_PixelShader = shader;
 629         }
 630 }
 631
 632
 633 }  // namespace