Refactor Renderer11::blit to use simpler control flow.

src/libGLESv2/renderer/Renderer11.cpp

@@ -2920,14 +2920,57 @@ bool Renderer11::getRenderTargetResource(gl::Renderbuffer *colorbuffer, unsigned
 bool Renderer11::blitRect(gl::Framebuffer *readTarget, const gl::Rectangle &readRect, gl::Framebuffer *drawTarget, const gl::Rectangle &drawRect,
                           bool blitRenderTarget, bool blitDepthStencil)
 {
-    if (blitRenderTarget && !blitRect(readTarget, readRect, drawTarget, drawRect, BLIT_RENDERTARGET))
+    // TODO: mrt blit support
+    if (blitRenderTarget)
     {
-        return false;
+        gl::Renderbuffer *readBuffer = readTarget->getReadColorbuffer();
+        gl::Renderbuffer *drawBuffer = drawTarget->getColorbuffer(0);
+
+        if (!readBuffer)
+        {
+            ERR("Failed to retrieve the read buffer from the read framebuffer.");
+            return gl::error(GL_OUT_OF_MEMORY, false);
+        }
+
+        if (!drawBuffer)
+        {
+            ERR("Failed to retrieve the draw buffer from the draw framebuffer.");
+            return gl::error(GL_OUT_OF_MEMORY, false);
+        }
+
+        RenderTarget *readRenderTarget = readBuffer->getRenderTarget();
+        RenderTarget *drawRenderTarget = drawBuffer->getRenderTarget();
+
+        if (!blitRenderbufferRect(readRect, drawRect, readRenderTarget, drawRenderTarget))
+        {
+            return false;
+        }
     }
 
-    if (blitDepthStencil && !blitRect(readTarget, readRect, drawTarget, drawRect, BLIT_DEPTHSTENCIL))
+    if (blitDepthStencil)
     {
-        return false;
+        gl::Renderbuffer *readBuffer = readTarget->getDepthOrStencilbuffer();
+        gl::Renderbuffer *drawBuffer = drawTarget->getDepthOrStencilbuffer();
+
+        if (!readBuffer)
+        {
+            ERR("Failed to retrieve the read depth-stencil buffer from the read framebuffer.");
+            return gl::error(GL_OUT_OF_MEMORY, false);
+        }
+
+        if (!drawBuffer)
+        {
+            ERR("Failed to retrieve the draw depth-stencil buffer from the draw framebuffer.");
+            return gl::error(GL_OUT_OF_MEMORY, false);
+        }
+
+        RenderTarget *readRenderTarget = readBuffer->getDepthStencil();
+        RenderTarget *drawRenderTarget = drawBuffer->getDepthStencil();
+
+        if (!blitRenderbufferRect(readRect, drawRect, readRenderTarget, drawRenderTarget))
+        {
+            return false;
+        }
     }
 
     return true;
@@ -3355,122 +3398,64 @@ void Renderer11::readTextureData(ID3D11Texture2D *texture, unsigned int subResou
     stagingTex = NULL;
 }
 
-bool Renderer11::blitRect(gl::Framebuffer *readTarget, const gl::Rectangle &readRect, gl::Framebuffer *drawTarget,
-                          const gl::Rectangle &drawRect, BlitTarget target)
+bool Renderer11::blitRenderbufferRect(const gl::Rectangle &readRect, const gl::Rectangle &drawRect, RenderTarget *readRenderTarget, RenderTarget *drawRenderTarget)
 {
-    // TODO: mrt support
     ASSERT(readRect.width == drawRect.width && readRect.height == drawRect.height);
 
-    gl::Renderbuffer *readBuffer = NULL;
-    switch (target)
-    {
-      case BLIT_RENDERTARGET:
-        readBuffer = readTarget->getColorbuffer(0);
-        break;
-      case BLIT_DEPTHSTENCIL:
-        readBuffer = readTarget->getDepthOrStencilbuffer();
-        break;
-      default: UNREACHABLE();
-    }
-    if (!readBuffer)
-    {
-        ERR("Failed to retrieve the color buffer from the read target.");
-        return gl::error(GL_OUT_OF_MEMORY, false);
-    }
-
-    RenderTarget11 *sourceRenderTarget = NULL;
-    switch (target)
-    {
-      case BLIT_RENDERTARGET:
-        sourceRenderTarget = RenderTarget11::makeRenderTarget11(readBuffer->getRenderTarget());
-        break;
-      case BLIT_DEPTHSTENCIL:
-        sourceRenderTarget = RenderTarget11::makeRenderTarget11(readBuffer->getDepthStencil());
-        break;
-      default: UNREACHABLE();
-    }
-    if (!sourceRenderTarget)
+    RenderTarget11 *readRenderTarget11 = RenderTarget11::makeRenderTarget11(readRenderTarget);
+    if (!readRenderTarget)
     {
-        ERR("Failed to retrieve the render target from the frame buffer.");
+        ERR("Failed to retrieve the read render target from the read framebuffer.");
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    ID3D11Texture2D *source = NULL;
-    unsigned int sourceSubresource = 0;
-    if (sourceRenderTarget->getSamples() > 0)
+    ID3D11Texture2D *readTexture = NULL;
+    unsigned int readSubresource = 0;
+    if (readRenderTarget->getSamples() > 0)
     {
-        ID3D11Texture2D *unresolvedTexture = sourceRenderTarget->getTexture();
+        ID3D11Texture2D *unresolvedTexture = readRenderTarget11->getTexture();
 
-        source = resolveMultisampledTexture(unresolvedTexture, sourceRenderTarget->getSubresourceIndex());
-        sourceSubresource = 0;
+        readTexture = resolveMultisampledTexture(unresolvedTexture, readRenderTarget11->getSubresourceIndex());
+        readSubresource = 0;
 
         unresolvedTexture->Release();
     }
     else
     {
-        source = sourceRenderTarget->getTexture();
-        sourceSubresource = sourceRenderTarget->getSubresourceIndex();
+        readTexture = readRenderTarget11->getTexture();
+        readSubresource = readRenderTarget11->getSubresourceIndex();
     }
 
-    if (!source)
-    {
-        ERR("Failed to retrieve the render target view from the render target.");
-        return gl::error(GL_OUT_OF_MEMORY, false);
-    }
-
-
-    gl::Renderbuffer *drawBuffer = NULL;
-    switch (target)
-    {
-      case BLIT_RENDERTARGET:
-        drawBuffer = drawTarget->getColorbuffer(0);
-        break;
-      case BLIT_DEPTHSTENCIL:
-        drawBuffer = drawTarget->getDepthOrStencilbuffer();
-        break;
-      default: UNREACHABLE();
-    }
-    if (!drawBuffer)
+    if (!readTexture)
     {
-        source->Release();
-        ERR("Failed to retrieve the color buffer from the draw buffer.");
+        ERR("Failed to retrieve the read render target view from the read render target.");
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    RenderTarget11 *drawRenderTarget = NULL;
-    switch (target)
-    {
-      case BLIT_RENDERTARGET:
-        drawRenderTarget = RenderTarget11::makeRenderTarget11(drawBuffer->getRenderTarget());
-        break;
-      case BLIT_DEPTHSTENCIL:
-        drawRenderTarget = RenderTarget11::makeRenderTarget11(drawBuffer->getDepthStencil());
-        break;
-      default: UNREACHABLE();
-    }
+    RenderTarget11 *drawRenderTarget11 = RenderTarget11::makeRenderTarget11(drawRenderTarget);
     if (!drawRenderTarget)
     {
-        source->Release();
-        ERR("Failed to retrieve the render target from the render buffer.");
+        readTexture->Release();
+        ERR("Failed to retrieve the draw render target from the draw framebuffer.");
         return gl::error(GL_OUT_OF_MEMORY, false);
     }
 
-    ID3D11Texture2D *dest = drawRenderTarget->getTexture();
-    unsigned int destSubresource = drawRenderTarget->getSubresourceIndex();
+    ID3D11Texture2D *drawTexture = drawRenderTarget11->getTexture();
+    unsigned int drawSubresource = drawRenderTarget11->getSubresourceIndex();
 
-    D3D11_BOX srcBox;
-    srcBox.left = readRect.x;
-    srcBox.right = readRect.x + readRect.width;
-    srcBox.top = readRect.y;
-    srcBox.bottom = readRect.y + readRect.height;
-    srcBox.front = 0;
-    srcBox.back = 1;
+    D3D11_BOX readBox;
+    readBox.left = readRect.x;
+    readBox.right = readRect.x + readRect.width;
+    readBox.top = readRect.y;
+    readBox.bottom = readRect.y + readRect.height;
+    readBox.front = 0;
+    readBox.back = 1;
 
-    mDeviceContext->CopySubresourceRegion(dest, destSubresource, drawRect.x, drawRect.y, 0,
-                                          source, sourceSubresource, &srcBox);
+    mDeviceContext->CopySubresourceRegion(drawTexture, drawSubresource, drawRect.x, drawRect.y, 0,
+                                          readTexture, readSubresource, &readBox);
 
-    source->Release();
-    dest->Release();
+    readTexture->Release();
+    drawTexture->Release();
 
     return true;
 }

src/libGLESv2/renderer/Renderer11.h

@@ -185,12 +185,6 @@ class Renderer11 : public Renderer
   private:
     DISALLOW_COPY_AND_ASSIGN(Renderer11);
 
-    enum BlitTarget
-    {
-        BLIT_RENDERTARGET,
-        BLIT_DEPTHSTENCIL,
-    };
-
     void drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer);
     void drawTriangleFan(GLsizei count, GLenum type, const GLvoid *indices, int minIndex, gl::Buffer *elementArrayBuffer, int instances);
 
@@ -201,8 +195,7 @@ class Renderer11 : public Renderer
     void maskedClear(const gl::ClearParameters &clearParams);
     rx::Range getViewportBounds() const;
 
-    bool blitRect(gl::Framebuffer *readTarget, const gl::Rectangle &readRect, gl::Framebuffer *drawTarget,
-                  const gl::Rectangle &drawRect, BlitTarget target);
+    bool blitRenderbufferRect(const gl::Rectangle &readRect, const gl::Rectangle &drawRect, RenderTarget *readRenderTarget, RenderTarget *drawRenderTarget);
     ID3D11Texture2D *resolveMultisampledTexture(ID3D11Texture2D *source, unsigned int subresource);
 
     HMODULE mD3d11Module;