src/third_party/angle/src/libGLESv2/renderer/d3d/d3d9/Blit9.cpp

   1 //
   2 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5 //
   6
   7 // Blit9.cpp: Surface copy utility class.
   8
   9 #include "libGLESv2/renderer/d3d/d3d9/Blit9.h"
  10 #include "libGLESv2/renderer/d3d/d3d9/renderer9_utils.h"
  11 #include "libGLESv2/renderer/d3d/d3d9/formatutils9.h"
  12 #include "libGLESv2/renderer/d3d/d3d9/TextureStorage9.h"
  13 #include "libGLESv2/renderer/d3d/d3d9/RenderTarget9.h"
  14 #include "libGLESv2/renderer/d3d/d3d9/Renderer9.h"
  15 #include "libGLESv2/Framebuffer.h"
  16 #include "libGLESv2/FramebufferAttachment.h"
  17 #include "libGLESv2/main.h"
  18
  19 namespace
  20 {
  21 // Precompiled shaders
  22 #include "libGLESv2/renderer/d3d/d3d9/shaders/compiled/standardvs.h"
  23 #include "libGLESv2/renderer/d3d/d3d9/shaders/compiled/flipyvs.h"
  24 #include "libGLESv2/renderer/d3d/d3d9/shaders/compiled/passthroughps.h"
  25 #include "libGLESv2/renderer/d3d/d3d9/shaders/compiled/luminanceps.h"
  26 #include "libGLESv2/renderer/d3d/d3d9/shaders/compiled/componentmaskps.h"
  27
  28 const BYTE* const g_shaderCode[] =
  29 {
  30     g_vs20_standardvs,
  31     g_vs20_flipyvs,
  32     g_ps20_passthroughps,
  33     g_ps20_luminanceps,
  34     g_ps20_componentmaskps
  35 };
  36
  37 const size_t g_shaderSize[] =
  38 {
  39     sizeof(g_vs20_standardvs),
  40     sizeof(g_vs20_flipyvs),
  41     sizeof(g_ps20_passthroughps),
  42     sizeof(g_ps20_luminanceps),
  43     sizeof(g_ps20_componentmaskps)
  44 };
  45 }
  46
  47 namespace rx
  48 {
  49 Blit9::Blit9(rx::Renderer9 *renderer)
  50   : mRenderer(renderer), mQuadVertexBuffer(NULL), mQuadVertexDeclaration(NULL), mSavedStateBlock(NULL), mSavedRenderTarget(NULL), mSavedDepthStencil(NULL)
  51 {
  52     initGeometry();
  53     memset(mCompiledShaders, 0, sizeof(mCompiledShaders));
  54 }
  55
  56 Blit9::~Blit9()
  57 {
  58     SafeRelease(mSavedStateBlock);
  59     SafeRelease(mQuadVertexBuffer);
  60     SafeRelease(mQuadVertexDeclaration);
  61
  62     for (int i = 0; i < SHADER_COUNT; i++)
  63     {
  64         SafeRelease(mCompiledShaders[i]);
  65     }
  66 }
  67
  68 void Blit9::initGeometry()
  69 {
  70     static const float quad[] =
  71     {
  72         -1, -1,
  73         -1,  1,
  74          1, -1,
  75          1,  1
  76     };
  77
  78     IDirect3DDevice9 *device = mRenderer->getDevice();
  79
  80     HRESULT result = device->CreateVertexBuffer(sizeof(quad), D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, &mQuadVertexBuffer, NULL);
  81
  82     if (FAILED(result))
  83     {
  84         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
  85         return gl::error(GL_OUT_OF_MEMORY);
  86     }
  87
  88     void *lockPtr = NULL;
  89     result = mQuadVertexBuffer->Lock(0, 0, &lockPtr, 0);
  90
  91     if (FAILED(result) || lockPtr == NULL)
  92     {
  93         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
  94         return gl::error(GL_OUT_OF_MEMORY);
  95     }
  96
  97     memcpy(lockPtr, quad, sizeof(quad));
  98     mQuadVertexBuffer->Unlock();
  99
 100     static const D3DVERTEXELEMENT9 elements[] =
 101     {
 102         { 0, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
 103         D3DDECL_END()
 104     };
 105
 106     result = device->CreateVertexDeclaration(elements, &mQuadVertexDeclaration);
 107
 108     if (FAILED(result))
 109     {
 110         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
 111         return gl::error(GL_OUT_OF_MEMORY);
 112     }
 113 }
 114
 115 template <class D3DShaderType>
 116 bool Blit9::setShader(ShaderId source, const char *profile,
 117                      D3DShaderType *(rx::Renderer9::*createShader)(const DWORD *, size_t length),
 118                      HRESULT (WINAPI IDirect3DDevice9::*setShader)(D3DShaderType*))
 119 {
 120     IDirect3DDevice9 *device = mRenderer->getDevice();
 121
 122     D3DShaderType *shader;
 123
 124     if (mCompiledShaders[source] != NULL)
 125     {
 126         shader = static_cast<D3DShaderType*>(mCompiledShaders[source]);
 127     }
 128     else
 129     {
 130         const BYTE* shaderCode = g_shaderCode[source];
 131         size_t shaderSize = g_shaderSize[source];
 132
 133         shader = (mRenderer->*createShader)(reinterpret_cast<const DWORD*>(shaderCode), shaderSize);
 134         if (!shader)
 135         {
 136             ERR("Failed to create shader for blit operation");
 137             return false;
 138         }
 139
 140         mCompiledShaders[source] = shader;
 141     }
 142
 143     HRESULT hr = (device->*setShader)(shader);
 144
 145     if (FAILED(hr))
 146     {
 147         ERR("Failed to set shader for blit operation");
 148         return false;
 149     }
 150
 151     return true;
 152 }
 153
 154 bool Blit9::setVertexShader(ShaderId shader)
 155 {
 156     return setShader<IDirect3DVertexShader9>(shader, "vs_2_0", &rx::Renderer9::createVertexShader, &IDirect3DDevice9::SetVertexShader);
 157 }
 158
 159 bool Blit9::setPixelShader(ShaderId shader)
 160 {
 161     return setShader<IDirect3DPixelShader9>(shader, "ps_2_0", &rx::Renderer9::createPixelShader, &IDirect3DDevice9::SetPixelShader);
 162 }
 163
 164 RECT Blit9::getSurfaceRect(IDirect3DSurface9 *surface) const
 165 {
 166     D3DSURFACE_DESC desc;
 167     surface->GetDesc(&desc);
 168
 169     RECT rect;
 170     rect.left = 0;
 171     rect.top = 0;
 172     rect.right = desc.Width;
 173     rect.bottom = desc.Height;
 174
 175     return rect;
 176 }
 177
 178 bool Blit9::boxFilter(IDirect3DSurface9 *source, IDirect3DSurface9 *dest)
 179 {
 180     IDirect3DTexture9 *texture = copySurfaceToTexture(source, getSurfaceRect(source));
 181     if (!texture)
 182     {
 183         return false;
 184     }
 185
 186     IDirect3DDevice9 *device = mRenderer->getDevice();
 187
 188     saveState();
 189
 190     device->SetTexture(0, texture);
 191     device->SetRenderTarget(0, dest);
 192
 193     setVertexShader(SHADER_VS_STANDARD);
 194     setPixelShader(SHADER_PS_PASSTHROUGH);
 195
 196     setCommonBlitState();
 197     device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
 198     device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
 199
 200     setViewport(getSurfaceRect(dest), 0, 0);
 201
 202     render();
 203
 204     SafeRelease(texture);
 205
 206     restoreState();
 207
 208     return true;
 209 }
 210
 211 bool Blit9::copy2D(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, TextureStorage *storage, GLint level)
 212 {
 213     RenderTarget9 *renderTarget = NULL;
 214     IDirect3DSurface9 *source = NULL;
 215     gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(0);
 216
 217     if (colorbuffer)
 218     {
 219         renderTarget = d3d9::GetAttachmentRenderTarget(colorbuffer);
 220     }
 221
 222     if (renderTarget)
 223     {
 224         source = renderTarget->getSurface();
 225     }
 226
 227     if (!source)
 228     {
 229         ERR("Failed to retrieve the render target.");
 230         return gl::error(GL_OUT_OF_MEMORY, false);
 231     }
 232
 233     TextureStorage9_2D *storage9 = TextureStorage9_2D::makeTextureStorage9_2D(storage);
 234     IDirect3DSurface9 *destSurface = storage9->getSurfaceLevel(level, true);
 235     bool result = false;
 236
 237     if (destSurface)
 238     {
 239         result = copy(source, sourceRect, destFormat, xoffset, yoffset, destSurface);
 240         SafeRelease(destSurface);
 241     }
 242
 243     SafeRelease(source);
 244     return result;
 245 }
 246
 247 bool Blit9::copyCube(gl::Framebuffer *framebuffer, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, TextureStorage *storage, GLenum target, GLint level)
 248 {
 249     RenderTarget9 *renderTarget = NULL;
 250     IDirect3DSurface9 *source = NULL;
 251     gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(0);
 252
 253     if (colorbuffer)
 254     {
 255         renderTarget = d3d9::GetAttachmentRenderTarget(colorbuffer);
 256     }
 257
 258     if (renderTarget)
 259     {
 260         source = renderTarget->getSurface();
 261     }
 262
 263     if (!source)
 264     {
 265         ERR("Failed to retrieve the render target.");
 266         return gl::error(GL_OUT_OF_MEMORY, false);
 267     }
 268
 269     TextureStorage9_Cube *storage9 = TextureStorage9_Cube::makeTextureStorage9_Cube(storage);
 270     IDirect3DSurface9 *destSurface = storage9->getCubeMapSurface(target, level, true);
 271     bool result = false;
 272
 273     if (destSurface)
 274     {
 275         result = copy(source, sourceRect, destFormat, xoffset, yoffset, destSurface);
 276         SafeRelease(destSurface);
 277     }
 278
 279     SafeRelease(source);
 280     return result;
 281 }
 282
 283 bool Blit9::copy(IDirect3DSurface9 *source, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, IDirect3DSurface9 *dest)
 284 {
 285     if (!dest)
 286     {
 287         return false;
 288     }
 289
 290     IDirect3DDevice9 *device = mRenderer->getDevice();
 291
 292     D3DSURFACE_DESC sourceDesc;
 293     D3DSURFACE_DESC destDesc;
 294     source->GetDesc(&sourceDesc);
 295     dest->GetDesc(&destDesc);
 296
 297     if (sourceDesc.Format == destDesc.Format && destDesc.Usage & D3DUSAGE_RENDERTARGET &&
 298         d3d9_gl::IsFormatChannelEquivalent(destDesc.Format, destFormat))   // Can use StretchRect
 299     {
 300         RECT destRect = {xoffset, yoffset, xoffset + (sourceRect.right - sourceRect.left), yoffset + (sourceRect.bottom - sourceRect.top)};
 301         HRESULT result = device->StretchRect(source, &sourceRect, dest, &destRect, D3DTEXF_POINT);
 302
 303         if (FAILED(result))
 304         {
 305             ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
 306             return gl::error(GL_OUT_OF_MEMORY, false);
 307         }
 308     }
 309     else
 310     {
 311         return formatConvert(source, sourceRect, destFormat, xoffset, yoffset, dest);
 312     }
 313     return true;
 314 }
 315
 316 bool Blit9::formatConvert(IDirect3DSurface9 *source, const RECT &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, IDirect3DSurface9 *dest)
 317 {
 318     IDirect3DTexture9 *texture = copySurfaceToTexture(source, sourceRect);
 319     if (!texture)
 320     {
 321         return false;
 322     }
 323
 324     IDirect3DDevice9 *device = mRenderer->getDevice();
 325
 326     saveState();
 327
 328     device->SetTexture(0, texture);
 329     device->SetRenderTarget(0, dest);
 330
 331     setViewport(sourceRect, xoffset, yoffset);
 332
 333     setCommonBlitState();
 334     if (setFormatConvertShaders(destFormat))
 335     {
 336         render();
 337     }
 338
 339     SafeRelease(texture);
 340
 341     restoreState();
 342
 343     return true;
 344 }
 345
 346 bool Blit9::setFormatConvertShaders(GLenum destFormat)
 347 {
 348     bool okay = setVertexShader(SHADER_VS_STANDARD);
 349
 350     switch (destFormat)
 351     {
 352       default: UNREACHABLE();
 353       case GL_RGBA:
 354       case GL_BGRA_EXT:
 355       case GL_RGB:
 356       case GL_RG_EXT:
 357       case GL_RED_EXT:
 358       case GL_ALPHA:
 359         okay = okay && setPixelShader(SHADER_PS_COMPONENTMASK);
 360         break;
 361
 362       case GL_LUMINANCE:
 363       case GL_LUMINANCE_ALPHA:
 364         okay = okay && setPixelShader(SHADER_PS_LUMINANCE);
 365         break;
 366     }
 367
 368     if (!okay)
 369     {
 370         return false;
 371     }
 372
 373     enum { X = 0, Y = 1, Z = 2, W = 3 };
 374
 375     // The meaning of this constant depends on the shader that was selected.
 376     // See the shader assembly code above for details.
 377     // Allocate one array for both registers and split it into two float4's.
 378     float psConst[8] = { 0 };
 379     float *multConst = &psConst[0];
 380     float *addConst = &psConst[4];
 381
 382     switch (destFormat)
 383     {
 384       default: UNREACHABLE();
 385       case GL_RGBA:
 386       case GL_BGRA_EXT:
 387         multConst[X] = 1;
 388         multConst[Y] = 1;
 389         multConst[Z] = 1;
 390         multConst[W] = 1;
 391         addConst[X] = 0;
 392         addConst[Y] = 0;
 393         addConst[Z] = 0;
 394         addConst[W] = 0;
 395         break;
 396
 397       case GL_RGB:
 398         multConst[X] = 1;
 399         multConst[Y] = 1;
 400         multConst[Z] = 1;
 401         multConst[W] = 0;
 402         addConst[X] = 0;
 403         addConst[Y] = 0;
 404         addConst[Z] = 0;
 405         addConst[W] = 1;
 406         break;
 407
 408       case GL_RG_EXT:
 409         multConst[X] = 1;
 410         multConst[Y] = 1;
 411         multConst[Z] = 0;
 412         multConst[W] = 0;
 413         addConst[X] = 0;
 414         addConst[Y] = 0;
 415         addConst[Z] = 0;
 416         addConst[W] = 1;
 417         break;
 418
 419       case GL_RED_EXT:
 420         multConst[X] = 1;
 421         multConst[Y] = 0;
 422         multConst[Z] = 0;
 423         multConst[W] = 0;
 424         addConst[X] = 0;
 425         addConst[Y] = 0;
 426         addConst[Z] = 0;
 427         addConst[W] = 1;
 428         break;
 429
 430       case GL_ALPHA:
 431         multConst[X] = 0;
 432         multConst[Y] = 0;
 433         multConst[Z] = 0;
 434         multConst[W] = 1;
 435         addConst[X] = 0;
 436         addConst[Y] = 0;
 437         addConst[Z] = 0;
 438         addConst[W] = 0;
 439         break;
 440
 441       case GL_LUMINANCE:
 442         multConst[X] = 1;
 443         multConst[Y] = 0;
 444         multConst[Z] = 0;
 445         multConst[W] = 0;
 446         addConst[X] = 0;
 447         addConst[Y] = 0;
 448         addConst[Z] = 0;
 449         addConst[W] = 1;
 450         break;
 451
 452       case GL_LUMINANCE_ALPHA:
 453         multConst[X] = 1;
 454         multConst[Y] = 0;
 455         multConst[Z] = 0;
 456         multConst[W] = 1;
 457         addConst[X] = 0;
 458         addConst[Y] = 0;
 459         addConst[Z] = 0;
 460         addConst[W] = 0;
 461         break;
 462     }
 463
 464     mRenderer->getDevice()->SetPixelShaderConstantF(0, psConst, 2);
 465
 466     return true;
 467 }
 468
 469 IDirect3DTexture9 *Blit9::copySurfaceToTexture(IDirect3DSurface9 *surface, const RECT &sourceRect)
 470 {
 471     if (!surface)
 472     {
 473         return NULL;
 474     }
 475
 476     IDirect3DDevice9 *device = mRenderer->getDevice();
 477
 478     D3DSURFACE_DESC sourceDesc;
 479     surface->GetDesc(&sourceDesc);
 480
 481     // Copy the render target into a texture
 482     IDirect3DTexture9 *texture;
 483     HRESULT result = device->CreateTexture(sourceRect.right - sourceRect.left, sourceRect.bottom - sourceRect.top, 1, D3DUSAGE_RENDERTARGET, sourceDesc.Format, D3DPOOL_DEFAULT, &texture, NULL);
 484
 485     if (FAILED(result))
 486     {
 487         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
 488         return gl::error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
 489     }
 490
 491     IDirect3DSurface9 *textureSurface;
 492     result = texture->GetSurfaceLevel(0, &textureSurface);
 493
 494     if (FAILED(result))
 495     {
 496         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
 497         SafeRelease(texture);
 498         return gl::error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
 499     }
 500
 501     mRenderer->endScene();
 502     result = device->StretchRect(surface, &sourceRect, textureSurface, NULL, D3DTEXF_NONE);
 503
 504     SafeRelease(textureSurface);
 505
 506     if (FAILED(result))
 507     {
 508         ASSERT(result == D3DERR_OUTOFVIDEOMEMORY || result == E_OUTOFMEMORY);
 509         SafeRelease(texture);
 510         return gl::error(GL_OUT_OF_MEMORY, (IDirect3DTexture9*)NULL);
 511     }
 512
 513     return texture;
 514 }
 515
 516 void Blit9::setViewport(const RECT &sourceRect, GLint xoffset, GLint yoffset)
 517 {
 518     IDirect3DDevice9 *device = mRenderer->getDevice();
 519
 520     D3DVIEWPORT9 vp;
 521     vp.X      = xoffset;
 522     vp.Y      = yoffset;
 523     vp.Width  = sourceRect.right - sourceRect.left;
 524     vp.Height = sourceRect.bottom - sourceRect.top;
 525     vp.MinZ   = 0.0f;
 526     vp.MaxZ   = 1.0f;
 527     device->SetViewport(&vp);
 528
 529     float halfPixelAdjust[4] = { -1.0f/vp.Width, 1.0f/vp.Height, 0, 0 };
 530     device->SetVertexShaderConstantF(0, halfPixelAdjust, 1);
 531 }
 532
 533 void Blit9::setCommonBlitState()
 534 {
 535     IDirect3DDevice9 *device = mRenderer->getDevice();
 536
 537     device->SetDepthStencilSurface(NULL);
 538
 539     device->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
 540     device->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
 541     device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
 542     device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
 543     device->SetRenderState(D3DRS_CLIPPLANEENABLE, 0);
 544     device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED);
 545     device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE);
 546     device->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
 547
 548     device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
 549     device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
 550     device->SetSamplerState(0, D3DSAMP_SRGBTEXTURE, FALSE);
 551     device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
 552     device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
 553
 554     RECT scissorRect = {0};   // Scissoring is disabled for flipping, but we need this to capture and restore the old rectangle
 555     device->SetScissorRect(&scissorRect);
 556
 557     for(int i = 0; i < gl::MAX_VERTEX_ATTRIBS; i++)
 558     {
 559         device->SetStreamSourceFreq(i, 1);
 560     }
 561 }
 562
 563 void Blit9::render()
 564 {
 565     IDirect3DDevice9 *device = mRenderer->getDevice();
 566
 567     HRESULT hr = device->SetStreamSource(0, mQuadVertexBuffer, 0, 2 * sizeof(float));
 568     hr = device->SetVertexDeclaration(mQuadVertexDeclaration);
 569
 570     mRenderer->startScene();
 571     hr = device->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
 572 }
 573
 574 void Blit9::saveState()
 575 {
 576     IDirect3DDevice9 *device = mRenderer->getDevice();
 577
 578     HRESULT hr;
 579
 580     device->GetDepthStencilSurface(&mSavedDepthStencil);
 581     device->GetRenderTarget(0, &mSavedRenderTarget);
 582
 583     if (mSavedStateBlock == NULL)
 584     {
 585         hr = device->BeginStateBlock();
 586         ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY);
 587
 588         setCommonBlitState();
 589
 590         static const float dummyConst[8] = { 0 };
 591
 592         device->SetVertexShader(NULL);
 593         device->SetVertexShaderConstantF(0, dummyConst, 2);
 594         device->SetPixelShader(NULL);
 595         device->SetPixelShaderConstantF(0, dummyConst, 2);
 596
 597         D3DVIEWPORT9 dummyVp;
 598         dummyVp.X = 0;
 599         dummyVp.Y = 0;
 600         dummyVp.Width = 1;
 601         dummyVp.Height = 1;
 602         dummyVp.MinZ = 0;
 603         dummyVp.MaxZ = 1;
 604
 605         device->SetViewport(&dummyVp);
 606
 607         device->SetTexture(0, NULL);
 608
 609         device->SetStreamSource(0, mQuadVertexBuffer, 0, 0);
 610
 611         device->SetVertexDeclaration(mQuadVertexDeclaration);
 612
 613         hr = device->EndStateBlock(&mSavedStateBlock);
 614         ASSERT(SUCCEEDED(hr) || hr == D3DERR_OUTOFVIDEOMEMORY || hr == E_OUTOFMEMORY);
 615     }
 616
 617     ASSERT(mSavedStateBlock != NULL);
 618
 619     if (mSavedStateBlock != NULL)
 620     {
 621         hr = mSavedStateBlock->Capture();
 622         ASSERT(SUCCEEDED(hr));
 623     }
 624 }
 625
 626 void Blit9::restoreState()
 627 {
 628     IDirect3DDevice9 *device = mRenderer->getDevice();
 629
 630     device->SetDepthStencilSurface(mSavedDepthStencil);
 631     SafeRelease(mSavedDepthStencil);
 632
 633     device->SetRenderTarget(0, mSavedRenderTarget);
 634     SafeRelease(mSavedRenderTarget);
 635
 636     ASSERT(mSavedStateBlock != NULL);
 637
 638     if (mSavedStateBlock != NULL)
 639     {
 640         mSavedStateBlock->Apply();
 641     }
 642 }
 643
 644 }