Revert "Query attachment render targets from Impl class."

src/libANGLE/FramebufferAttachment.h

@@ -12,7 +12,6 @@
 
 #include "angle_gl.h"
 #include "common/angleutils.h"
-#include "libANGLE/Error.h"
 #include "libANGLE/ImageIndex.h"
 #include "libANGLE/RefCountObject.h"
 
@@ -21,20 +20,6 @@ namespace egl
 class Surface;
 }
 
-namespace rx
-{
-// An implementation-specific object associated with an attachment.
-
-class FramebufferAttachmentRenderTarget : angle::NonCopyable
-{
-  public:
-    FramebufferAttachmentRenderTarget() {}
-    virtual ~FramebufferAttachmentRenderTarget() {}
-};
-
-class FramebufferAttachmentObjectImpl;
-}
-
 namespace gl
 {
 class FramebufferAttachmentObject;
@@ -134,20 +119,7 @@ class FramebufferAttachment final
     Texture *getTexture() const;
     const egl::Surface *getSurface() const;
 
-    // "T" must be static_castable from FramebufferAttachmentRenderTarget
-    template <typename T>
-    gl::Error getRenderTarget(T **rtOut) const
-    {
-        // Cast through the pointer-to-pointer type
-        rx::FramebufferAttachmentRenderTarget *rtPtr = nullptr;
-        gl::Error error = getRenderTarget(&rtPtr);
-        *rtOut = static_cast<T*>(rtPtr);
-        return error;
-    }
-
   private:
-    gl::Error getRenderTarget(rx::FramebufferAttachmentRenderTarget **rtOut) const;
-
     GLenum mType;
     Target mTarget;
     BindingPointer<FramebufferAttachmentObject> mResource;
@@ -163,12 +135,6 @@ class FramebufferAttachmentObject : public RefCountObject
     virtual GLsizei getAttachmentHeight(const FramebufferAttachment::Target &target) const = 0;
     virtual GLenum getAttachmentInternalFormat(const FramebufferAttachment::Target &target) const = 0;
     virtual GLsizei getAttachmentSamples(const FramebufferAttachment::Target &target) const = 0;
-
-    Error getAttachmentRenderTarget(const FramebufferAttachment::Target &target,
-                                    rx::FramebufferAttachmentRenderTarget **rtOut) const;
-
-  protected:
-    virtual rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const = 0;
 };
 
 inline GLsizei FramebufferAttachment::getWidth() const
@@ -191,38 +157,6 @@ inline GLsizei FramebufferAttachment::getSamples() const
     return mResource->getAttachmentSamples(mTarget);
 }
 
-inline gl::Error FramebufferAttachment::getRenderTarget(rx::FramebufferAttachmentRenderTarget **rtOut) const
-{
-    return mResource->getAttachmentRenderTarget(mTarget, rtOut);
-}
-
-} // namespace gl
-
-namespace rx
-{
-
-class FramebufferAttachmentObjectImpl : angle::NonCopyable
-{
-  public:
-    FramebufferAttachmentObjectImpl() {}
-    virtual ~FramebufferAttachmentObjectImpl() {}
-
-    virtual gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                                FramebufferAttachmentRenderTarget **rtOut) = 0;
-};
-
-} // namespace rx
-
-namespace gl
-{
-
-inline Error FramebufferAttachmentObject::getAttachmentRenderTarget(
-    const FramebufferAttachment::Target &target,
-    rx::FramebufferAttachmentRenderTarget **rtOut) const
-{
-    return getAttachmentImpl()->getAttachmentRenderTarget(target, rtOut);
-}
-
 }
 
 #endif // LIBANGLE_FRAMEBUFFERATTACHMENT_H_

src/libANGLE/Renderbuffer.cpp

@@ -15,6 +15,7 @@
 #include "libANGLE/Texture.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/RenderTargetD3D.h"
+#include "libANGLE/renderer/RenderbufferImpl.h"
 
 namespace gl
 {

src/libANGLE/Renderbuffer.h

@@ -15,7 +15,11 @@
 #include "common/angleutils.h"
 #include "libANGLE/Error.h"
 #include "libANGLE/FramebufferAttachment.h"
-#include "libANGLE/renderer/RenderbufferImpl.h"
+
+namespace rx
+{
+class RenderbufferImpl;
+}
 
 namespace gl
 {
@@ -54,8 +58,6 @@ class Renderbuffer : public FramebufferAttachmentObject
     GLsizei getAttachmentSamples(const FramebufferAttachment::Target &/*target*/) const override { return getSamples(); }
 
   private:
-    rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const override { return mRenderbuffer; }
-
     rx::RenderbufferImpl *mRenderbuffer;
 
     GLsizei mWidth;

src/libANGLE/Surface.cpp

@@ -12,6 +12,7 @@
 
 #include "libANGLE/Config.h"
 #include "libANGLE/Texture.h"
+#include "libANGLE/renderer/SurfaceImpl.h"
 
 #include <EGL/eglext.h>
 

src/libANGLE/Surface.h

@@ -16,13 +16,17 @@
 #include "common/angleutils.h"
 #include "libANGLE/Error.h"
 #include "libANGLE/FramebufferAttachment.h"
-#include "libANGLE/renderer/SurfaceImpl.h"
 
 namespace gl
 {
 class Texture;
 }
 
+namespace rx
+{
+class SurfaceImpl;
+}
+
 namespace egl
 {
 class AttributeMap;
@@ -72,7 +76,6 @@ class Surface final : public gl::FramebufferAttachmentObject
 
   private:
     virtual ~Surface();
-    rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const override { return mImplementation; }
 
     rx::SurfaceImpl *mImplementation;
 

src/libANGLE/Surface_unittest.cpp

@@ -29,7 +29,6 @@ class MockSurfaceImpl : public rx::SurfaceImpl
     MOCK_CONST_METHOD0(getWidth, EGLint());
     MOCK_CONST_METHOD0(getHeight, EGLint());
     MOCK_CONST_METHOD0(isPostSubBufferSupported, EGLint(void));
-    MOCK_METHOD2(getAttachmentRenderTarget, gl::Error(const gl::FramebufferAttachment::Target &, rx::FramebufferAttachmentRenderTarget **));
 
     MOCK_METHOD0(destroy, void());
 };

src/libANGLE/Texture.cpp

@@ -14,6 +14,7 @@
 #include "libANGLE/Data.h"
 #include "libANGLE/Surface.h"
 #include "libANGLE/formatutils.h"
+#include "libANGLE/renderer/TextureImpl.h"
 
 namespace gl
 {

src/libANGLE/Texture.h

@@ -19,13 +19,17 @@
 #include "libANGLE/Error.h"
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/angletypes.h"
-#include "libANGLE/renderer/TextureImpl.h"
 
 namespace egl
 {
 class Surface;
 }
 
+namespace rx
+{
+class TextureImpl;
+}
+
 namespace gl
 {
 class Framebuffer;
@@ -97,7 +101,6 @@ class Texture final : public FramebufferAttachmentObject
     GLsizei getAttachmentSamples(const FramebufferAttachment::Target &target) const override;
 
   private:
-    rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const override { return mTexture; }
     static unsigned int issueTextureSerial();
 
     rx::TextureImpl *mTexture;

src/libANGLE/renderer/RenderbufferImpl.h

@@ -12,12 +12,11 @@
 #include "angle_gl.h"
 #include "common/angleutils.h"
 #include "libANGLE/Error.h"
-#include "libANGLE/FramebufferAttachment.h"
 
 namespace rx
 {
 
-class RenderbufferImpl : public FramebufferAttachmentObjectImpl
+class RenderbufferImpl : angle::NonCopyable
 {
   public:
     RenderbufferImpl();

src/libANGLE/renderer/SurfaceImpl.h

@@ -11,7 +11,6 @@
 
 #include "common/angleutils.h"
 #include "libANGLE/Error.h"
-#include "libANGLE/FramebufferAttachment.h"
 
 namespace egl
 {
@@ -22,7 +21,7 @@ struct Config;
 namespace rx
 {
 
-class SurfaceImpl : public FramebufferAttachmentObjectImpl
+class SurfaceImpl : angle::NonCopyable
 {
   public:
     SurfaceImpl();

src/libANGLE/renderer/TextureImpl.h

@@ -14,7 +14,6 @@
 #include "angle_gl.h"
 #include "common/angleutils.h"
 #include "libANGLE/Error.h"
-#include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/ImageIndex.h"
 
 namespace egl
@@ -36,7 +35,7 @@ struct SamplerState;
 namespace rx
 {
 
-class TextureImpl : public FramebufferAttachmentObjectImpl
+class TextureImpl : angle::NonCopyable
 {
   public:
     TextureImpl() {}

src/libANGLE/renderer/d3d/FramebufferD3D.cpp

@@ -226,7 +226,7 @@ GLenum FramebufferD3D::getImplementationColorReadFormat() const
     }
 
     RenderTargetD3D *attachmentRenderTarget = NULL;
-    gl::Error error = readAttachment->getRenderTarget(&attachmentRenderTarget);
+    gl::Error error = GetAttachmentRenderTarget(readAttachment, &attachmentRenderTarget);
     if (error.isError())
     {
         return GL_NONE;
@@ -248,7 +248,7 @@ GLenum FramebufferD3D::getImplementationColorReadType() const
     }
 
     RenderTargetD3D *attachmentRenderTarget = NULL;
-    gl::Error error = readAttachment->getRenderTarget(&attachmentRenderTarget);
+    gl::Error error = GetAttachmentRenderTarget(readAttachment, &attachmentRenderTarget);
     if (error.isError())
     {
         return GL_NONE;
@@ -376,6 +376,48 @@ const gl::AttachmentList &FramebufferD3D::getColorAttachmentsForRender(const Wor
     return mColorAttachmentsForRender;
 }
 
+gl::Error GetAttachmentRenderTarget(const gl::FramebufferAttachment *attachment, RenderTargetD3D **outRT)
+{
+    if (attachment->type() == GL_TEXTURE)
+    {
+        gl::Texture *texture = attachment->getTexture();
+        ASSERT(texture);
+        TextureD3D *textureD3D = GetImplAs<TextureD3D>(texture);
+        const gl::ImageIndex &index = attachment->getTextureImageIndex();
+        return textureD3D->getRenderTarget(index, outRT);
+    }
+    else if (attachment->type() == GL_RENDERBUFFER)
+    {
+        gl::Renderbuffer *renderbuffer = attachment->getRenderbuffer();
+        ASSERT(renderbuffer);
+        RenderbufferD3D *renderbufferD3D = GetImplAs<RenderbufferD3D>(renderbuffer);
+        *outRT = renderbufferD3D->getRenderTarget();
+        return gl::Error(GL_NO_ERROR);
+    }
+    else if (attachment->type() == GL_FRAMEBUFFER_DEFAULT)
+    {
+        const egl::Surface *surface = attachment->getSurface();
+        ASSERT(surface);
+        const SurfaceD3D *surfaceD3D = GetImplAs<SurfaceD3D>(surface);
+        ASSERT(surfaceD3D);
+
+        if (attachment->getBinding() == GL_BACK)
+        {
+            *outRT = surfaceD3D->getSwapChain()->getColorRenderTarget();
+        }
+        else
+        {
+            *outRT = surfaceD3D->getSwapChain()->getDepthStencilRenderTarget();
+        }
+        return gl::Error(GL_NO_ERROR);
+    }
+    else
+    {
+        UNREACHABLE();
+        return gl::Error(GL_INVALID_OPERATION);
+    }
+}
+
 // Note: RenderTarget serials should ideally be in the RenderTargets themselves.
 unsigned int GetAttachmentSerial(const gl::FramebufferAttachment *attachment)
 {

src/libANGLE/renderer/d3d/FramebufferD3D.h

@@ -106,6 +106,7 @@ class FramebufferD3D : public FramebufferImpl
     virtual GLenum getRenderTargetImplementationFormat(RenderTargetD3D *renderTarget) const = 0;
 };
 
+gl::Error GetAttachmentRenderTarget(const gl::FramebufferAttachment *attachment, RenderTargetD3D **outRT);
 unsigned int GetAttachmentSerial(const gl::FramebufferAttachment *attachment);
 
 }

src/libANGLE/renderer/d3d/ImageD3D.cpp

@@ -13,7 +13,6 @@
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/renderer/d3d/FramebufferD3D.h"
-#include "libANGLE/renderer/d3d/RenderTargetD3D.h"
 
 namespace rx
 {
@@ -31,11 +30,11 @@ ImageD3D::ImageD3D()
 
 gl::Error ImageD3D::copy(const gl::Offset &destOffset, const gl::Rectangle &sourceArea, const gl::Framebuffer *source)
 {
-    const gl::FramebufferAttachment *srcAttachment = source->getReadColorbuffer();
-    ASSERT(srcAttachment);
+    const gl::FramebufferAttachment *colorbuffer = source->getReadColorbuffer();
+    ASSERT(colorbuffer);
 
     RenderTargetD3D *renderTarget = NULL;
-    gl::Error error = srcAttachment->getRenderTarget(&renderTarget);
+    gl::Error error = GetAttachmentRenderTarget(colorbuffer, &renderTarget);
     if (error.isError())
     {
         return error;

src/libANGLE/renderer/d3d/RenderTargetD3D.h

@@ -12,12 +12,11 @@
 
 #include "common/angleutils.h"
 #include "libANGLE/angletypes.h"
-#include "libANGLE/FramebufferAttachment.h"
 
 namespace rx
 {
 
-class RenderTargetD3D : public FramebufferAttachmentRenderTarget
+class RenderTargetD3D : angle::NonCopyable
 {
   public:
     RenderTargetD3D();

src/libANGLE/renderer/d3d/RenderbufferD3D.cpp

@@ -75,11 +75,4 @@ unsigned int RenderbufferD3D::getRenderTargetSerial() const
     return (mRenderTarget ? mRenderTarget->getSerial() : 0);
 }
 
-gl::Error RenderbufferD3D::getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                                     FramebufferAttachmentRenderTarget **rtOut)
-{
-    *rtOut = mRenderTarget;
-    return gl::Error(GL_NO_ERROR);
-}
-
 }

src/libANGLE/renderer/d3d/RenderbufferD3D.h

@@ -32,9 +32,6 @@ class RenderbufferD3D : public RenderbufferImpl
     RenderTargetD3D *getRenderTarget();
     unsigned int getRenderTargetSerial() const;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                        FramebufferAttachmentRenderTarget **rtOut) override;
-
   private:
     RendererD3D *mRenderer;
     RenderTargetD3D *mRenderTarget;

src/libANGLE/renderer/d3d/SurfaceD3D.cpp

@@ -12,7 +12,6 @@
 #include "libANGLE/Surface.h"
 #include "libANGLE/renderer/d3d/DisplayD3D.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
-#include "libANGLE/renderer/d3d/RenderTargetD3D.h"
 #include "libANGLE/renderer/d3d/SwapChainD3D.h"
 
 #include <tchar.h>
@@ -361,18 +360,4 @@ egl::Error SurfaceD3D::querySurfacePointerANGLE(EGLint attribute, void **value)
     return egl::Error(EGL_SUCCESS);
 }
 
-gl::Error SurfaceD3D::getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                                FramebufferAttachmentRenderTarget **rtOut)
-{
-    if (target.binding() == GL_BACK)
-    {
-        *rtOut = mSwapChain->getColorRenderTarget();
-    }
-    else
-    {
-        *rtOut = mSwapChain->getDepthStencilRenderTarget();
-    }
-    return gl::Error(GL_NO_ERROR);
-}
-
 }

src/libANGLE/renderer/d3d/SurfaceD3D.h

@@ -54,9 +54,6 @@ class SurfaceD3D : public SurfaceImpl
     // Returns true if swapchain changed due to resize or interval update
     bool checkForOutOfDateSwapChain();
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                        FramebufferAttachmentRenderTarget **rtOut) override;
-
   private:
     SurfaceD3D(RendererD3D *renderer, egl::Display *display, const egl::Config *config, EGLint width, EGLint height,
                EGLint fixedSize, EGLClientBuffer shareHandle, EGLNativeWindowType window);

src/libANGLE/renderer/d3d/TextureD3D.cpp

@@ -608,15 +608,6 @@ gl::Error TextureD3D::commitRegion(const gl::ImageIndex &index, const gl::Box &r
     return gl::Error(GL_NO_ERROR);
 }
 
-gl::Error TextureD3D::getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                                FramebufferAttachmentRenderTarget **rtOut)
-{
-    RenderTargetD3D *rtD3D = nullptr;
-    gl::Error error = getRenderTarget(target.textureIndex(), &rtD3D);
-    *rtOut = static_cast<FramebufferAttachmentRenderTarget *>(rtD3D);
-    return error;
-}
-
 TextureD3D_2D::TextureD3D_2D(RendererD3D *renderer)
     : TextureD3D(renderer)
 {

src/libANGLE/renderer/d3d/TextureD3D.h

@@ -64,9 +64,6 @@ class TextureD3D : public TextureImpl
     TextureStorage *getStorage();
     ImageD3D *getBaseLevelImage() const;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                        FramebufferAttachmentRenderTarget **rtOut) override;
-
   protected:
     gl::Error setImage(const gl::ImageIndex &index, GLenum type,
                        const gl::PixelUnpackState &unpack, const uint8_t *pixels,

src/libANGLE/renderer/d3d/d3d11/Clear11.cpp

@@ -260,7 +260,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
             drawBufferStates[colorAttachment] != GL_NONE)
         {
             RenderTarget11 *renderTarget = NULL;
-            gl::Error error = attachment.getRenderTarget(&renderTarget);
+            gl::Error error = d3d11::GetAttachmentRenderTarget(&attachment, &renderTarget);
             if (error.isError())
             {
                 return error;
@@ -349,7 +349,7 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, const gl
         ASSERT(attachment != nullptr);
 
         RenderTarget11 *renderTarget = NULL;
-        gl::Error error = attachment->getRenderTarget(&renderTarget);
+        gl::Error error = d3d11::GetAttachmentRenderTarget(attachment, &renderTarget);
         if (error.isError())
         {
             return error;

src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp

@@ -115,7 +115,7 @@ static gl::Error getRenderTargetResource(const gl::FramebufferAttachment *colorb
     ASSERT(colorbuffer);
 
     RenderTarget11 *renderTarget = nullptr;
-    gl::Error error = colorbuffer->getRenderTarget(&renderTarget);
+    gl::Error error = d3d11::GetAttachmentRenderTarget(colorbuffer, &renderTarget);
     if (error.isError())
     {
         return error;
@@ -189,7 +189,7 @@ gl::Error Framebuffer11::blit(const gl::Rectangle &sourceArea, const gl::Rectang
         ASSERT(readBuffer);
 
         RenderTargetD3D *readRenderTarget = nullptr;
-        gl::Error error = readBuffer->getRenderTarget(&readRenderTarget);
+        gl::Error error = GetAttachmentRenderTarget(readBuffer, &readRenderTarget);
         if (error.isError())
         {
             return error;
@@ -207,7 +207,7 @@ gl::Error Framebuffer11::blit(const gl::Rectangle &sourceArea, const gl::Rectang
                 drawBufferStates[colorAttachment] != GL_NONE)
             {
                 RenderTargetD3D *drawRenderTarget = nullptr;
-                error = drawBuffer.getRenderTarget(&drawRenderTarget);
+                error = GetAttachmentRenderTarget(&drawBuffer, &drawRenderTarget);
                 if (error.isError())
                 {
                     return error;
@@ -230,7 +230,7 @@ gl::Error Framebuffer11::blit(const gl::Rectangle &sourceArea, const gl::Rectang
         ASSERT(readBuffer);
 
         RenderTargetD3D *readRenderTarget = nullptr;
-        gl::Error error = readBuffer->getRenderTarget(&readRenderTarget);
+        gl::Error error = GetAttachmentRenderTarget(readBuffer, &readRenderTarget);
         if (error.isError())
         {
             return error;
@@ -241,7 +241,7 @@ gl::Error Framebuffer11::blit(const gl::Rectangle &sourceArea, const gl::Rectang
         ASSERT(drawBuffer);
 
         RenderTargetD3D *drawRenderTarget = nullptr;
-        error = drawBuffer->getRenderTarget(&drawRenderTarget);
+        error = GetAttachmentRenderTarget(drawBuffer, &drawRenderTarget);
         if (error.isError())
         {
             return error;

src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp

@@ -1290,7 +1290,7 @@ gl::Error Renderer11::applyRenderTarget(const gl::Framebuffer *framebuffer)
 
             // Extract the render target dimensions and view
             RenderTarget11 *renderTarget = NULL;
-            gl::Error error = colorbuffer->getRenderTarget(&renderTarget);
+            gl::Error error = d3d11::GetAttachmentRenderTarget(colorbuffer, &renderTarget);
             if (error.isError())
             {
                 return error;
@@ -1327,7 +1327,7 @@ gl::Error Renderer11::applyRenderTarget(const gl::Framebuffer *framebuffer)
     if (depthStencil)
     {
         RenderTarget11 *depthStencilRenderTarget = NULL;
-        gl::Error error = depthStencil->getRenderTarget(&depthStencilRenderTarget);
+        gl::Error error = d3d11::GetAttachmentRenderTarget(depthStencil, &depthStencilRenderTarget);
         if (error.isError())
         {
             SafeRelease(framebufferRTVs);
@@ -2423,7 +2423,7 @@ gl::Error Renderer11::copyImage2D(const gl::Framebuffer *framebuffer, const gl::
     ASSERT(colorbuffer);
 
     RenderTarget11 *sourceRenderTarget = NULL;
-    gl::Error error = colorbuffer->getRenderTarget(&sourceRenderTarget);
+    gl::Error error = d3d11::GetAttachmentRenderTarget(colorbuffer, &sourceRenderTarget);
     if (error.isError())
     {
         return error;
@@ -2474,7 +2474,7 @@ gl::Error Renderer11::copyImageCube(const gl::Framebuffer *framebuffer, const gl
     ASSERT(colorbuffer);
 
     RenderTarget11 *sourceRenderTarget = NULL;
-    gl::Error error = colorbuffer->getRenderTarget(&sourceRenderTarget);
+    gl::Error error = d3d11::GetAttachmentRenderTarget(colorbuffer, &sourceRenderTarget);
     if (error.isError())
     {
         return error;
@@ -2525,7 +2525,7 @@ gl::Error Renderer11::copyImage3D(const gl::Framebuffer *framebuffer, const gl::
     ASSERT(colorbuffer);
 
     RenderTarget11 *sourceRenderTarget = NULL;
-    gl::Error error = colorbuffer->getRenderTarget(&sourceRenderTarget);
+    gl::Error error = d3d11::GetAttachmentRenderTarget(colorbuffer, &sourceRenderTarget);
     if (error.isError())
     {
         return error;
@@ -2576,7 +2576,7 @@ gl::Error Renderer11::copyImage2DArray(const gl::Framebuffer *framebuffer, const
     ASSERT(colorbuffer);
 
     RenderTarget11 *sourceRenderTarget = NULL;
-    gl::Error error = colorbuffer->getRenderTarget(&sourceRenderTarget);
+    gl::Error error = d3d11::GetAttachmentRenderTarget(colorbuffer, &sourceRenderTarget);
     if (error.isError())
     {
         return error;

src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp

@@ -1189,6 +1189,18 @@ HRESULT SetDebugName(ID3D11DeviceChild *resource, const char *name)
 #endif
 }
 
+gl::Error GetAttachmentRenderTarget(const gl::FramebufferAttachment *attachment, RenderTarget11 **outRT)
+{
+    RenderTargetD3D *renderTarget = NULL;
+    gl::Error error = rx::GetAttachmentRenderTarget(attachment, &renderTarget);
+    if (error.isError())
+    {
+        return error;
+    }
+    *outRT = GetAs<RenderTarget11>(renderTarget);
+    return gl::Error(GL_NO_ERROR);
+}
+
 Workarounds GenerateWorkarounds(D3D_FEATURE_LEVEL featureLevel)
 {
     Workarounds workarounds;

src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h

@@ -179,6 +179,8 @@ inline void SetBufferData(ID3D11DeviceContext *context, ID3D11Buffer *constantBu
     context->Unmap(constantBuffer, 0);
 }
 
+gl::Error GetAttachmentRenderTarget(const gl::FramebufferAttachment *attachment, RenderTarget11 **outRT);
+
 Workarounds GenerateWorkarounds(D3D_FEATURE_LEVEL featureLevel);
 
 }

src/libANGLE/renderer/d3d/d3d9/Blit9.cpp

@@ -239,8 +239,8 @@ gl::Error Blit9::copy2D(const gl::Framebuffer *framebuffer, const RECT &sourceRe
     const gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(0);
     ASSERT(colorbuffer);
 
-    RenderTarget9 *renderTarget9 = nullptr;
-    error = colorbuffer->getRenderTarget(&renderTarget9);
+    RenderTarget9 *renderTarget9 = NULL;
+    error = d3d9::GetAttachmentRenderTarget(colorbuffer, &renderTarget9);
     if (error.isError())
     {
         return error;
@@ -278,8 +278,8 @@ gl::Error Blit9::copyCube(const gl::Framebuffer *framebuffer, const RECT &source
     const gl::FramebufferAttachment *colorbuffer = framebuffer->getColorbuffer(0);
     ASSERT(colorbuffer);
 
-    RenderTarget9 *renderTarget9 = nullptr;
-    error = colorbuffer->getRenderTarget(&renderTarget9);
+    RenderTarget9 *renderTarget9 = NULL;
+    error = d3d9::GetAttachmentRenderTarget(colorbuffer, &renderTarget9);
     if (error.isError())
     {
         return error;

src/libANGLE/renderer/d3d/d3d9/Framebuffer9.cpp

@@ -60,7 +60,7 @@ gl::Error Framebuffer9::readPixels(const gl::Rectangle &area, GLenum format, GLe
     ASSERT(colorbuffer);
 
     RenderTarget9 *renderTarget = nullptr;
-    gl::Error error = colorbuffer->getRenderTarget(&renderTarget);
+    gl::Error error = d3d9::GetAttachmentRenderTarget(colorbuffer, &renderTarget);
     if (error.isError())
     {
         return error;
@@ -247,7 +247,7 @@ gl::Error Framebuffer9::blit(const gl::Rectangle &sourceArea, const gl::Rectangl
         ASSERT(readBuffer);
 
         RenderTarget9 *readRenderTarget = nullptr;
-        gl::Error error = readBuffer->getRenderTarget(&readRenderTarget);
+        gl::Error error = d3d9::GetAttachmentRenderTarget(readBuffer, &readRenderTarget);
         if (error.isError())
         {
             return error;
@@ -258,7 +258,7 @@ gl::Error Framebuffer9::blit(const gl::Rectangle &sourceArea, const gl::Rectangl
         ASSERT(drawBuffer);
 
         RenderTarget9 *drawRenderTarget = nullptr;
-        error = drawBuffer->getRenderTarget(&drawRenderTarget);
+        error = d3d9::GetAttachmentRenderTarget(drawBuffer, &drawRenderTarget);
         if (error.isError())
         {
             return error;
@@ -373,7 +373,7 @@ gl::Error Framebuffer9::blit(const gl::Rectangle &sourceArea, const gl::Rectangl
         ASSERT(readBuffer);
 
         RenderTarget9 *readDepthStencil = nullptr;
-        gl::Error error = readBuffer->getRenderTarget(&readDepthStencil);
+        gl::Error error = d3d9::GetAttachmentRenderTarget(readBuffer, &readDepthStencil);
         if (error.isError())
         {
             return error;
@@ -384,7 +384,7 @@ gl::Error Framebuffer9::blit(const gl::Rectangle &sourceArea, const gl::Rectangl
         ASSERT(drawBuffer);
 
         RenderTarget9 *drawDepthStencil = nullptr;
-        error = drawBuffer->getRenderTarget(&drawDepthStencil);
+        error = d3d9::GetAttachmentRenderTarget(drawBuffer, &drawDepthStencil);
         if (error.isError())
         {
             return error;

src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp

@@ -1312,19 +1312,17 @@ gl::Error Renderer9::getNullColorbuffer(const gl::FramebufferAttachment *depthbu
 
 gl::Error Renderer9::applyRenderTarget(const gl::FramebufferAttachment *colorBuffer, const gl::FramebufferAttachment *depthStencilBuffer)
 {
-    const gl::FramebufferAttachment *renderAttachment = colorBuffer;
-
     // if there is no color attachment we must synthesize a NULL colorattachment
     // to keep the D3D runtime happy.  This should only be possible if depth texturing.
-    if (renderAttachment == nullptr)
+    if (!colorBuffer)
     {
-        gl::Error error = getNullColorbuffer(depthStencilBuffer, &renderAttachment);
+        gl::Error error = getNullColorbuffer(depthStencilBuffer, &colorBuffer);
         if (error.isError())
         {
             return error;
         }
     }
-    ASSERT(renderAttachment != nullptr);
+    ASSERT(colorBuffer);
 
     size_t renderTargetWidth = 0;
     size_t renderTargetHeight = 0;
@@ -1335,8 +1333,8 @@ gl::Error Renderer9::applyRenderTarget(const gl::FramebufferAttachment *colorBuf
     if (renderTargetSerial != mAppliedRenderTargetSerial)
     {
         // Apply the render target on the device
-        RenderTarget9 *renderTarget = nullptr;
-        gl::Error error = renderAttachment->getRenderTarget(&renderTarget);
+        RenderTarget9 *renderTarget = NULL;
+        gl::Error error = d3d9::GetAttachmentRenderTarget(colorBuffer, &renderTarget);
         if (error.isError())
         {
             return error;
@@ -1366,8 +1364,8 @@ gl::Error Renderer9::applyRenderTarget(const gl::FramebufferAttachment *colorBuf
         // Apply the depth stencil on the device
         if (depthStencilBuffer)
         {
-            RenderTarget9 *depthStencilRenderTarget = nullptr;
-            gl::Error error = depthStencilBuffer->getRenderTarget(&depthStencilRenderTarget);
+            RenderTarget9 *depthStencilRenderTarget = NULL;
+            gl::Error error = d3d9::GetAttachmentRenderTarget(depthStencilBuffer, &depthStencilRenderTarget);
             if (error.isError())
             {
                 return error;
@@ -2012,10 +2010,8 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
     unsigned int stencilUnmasked = 0x0;
     if (clearParams.clearStencil && depthStencilBuffer->getStencilSize() > 0)
     {
-        ASSERT(depthStencilBuffer != nullptr);
-
-        RenderTargetD3D *stencilRenderTarget = nullptr;
-        gl::Error error = depthStencilBuffer->getRenderTarget(&stencilRenderTarget);
+        RenderTargetD3D *stencilRenderTarget = NULL;
+        gl::Error error = GetAttachmentRenderTarget(depthStencilBuffer, &stencilRenderTarget);
         if (error.isError())
         {
             return error;
@@ -2035,10 +2031,8 @@ gl::Error Renderer9::clear(const ClearParameters &clearParams,
     D3DCOLOR color = D3DCOLOR_ARGB(255, 0, 0, 0);
     if (clearColor)
     {
-        ASSERT(colorBuffer != nullptr);
-
         RenderTargetD3D *colorRenderTarget = NULL;
-        gl::Error error = colorBuffer->getRenderTarget(&colorRenderTarget);
+        gl::Error error = GetAttachmentRenderTarget(colorBuffer, &colorRenderTarget);
         if (error.isError())
         {
             return error;

src/libANGLE/renderer/d3d/d3d9/renderer9_utils.cpp

@@ -574,6 +574,18 @@ void MakeValidSize(bool isImage, D3DFORMAT format, GLsizei *requestWidth, GLsize
     *levelOffset = upsampleCount;
 }
 
+gl::Error GetAttachmentRenderTarget(const gl::FramebufferAttachment *attachment, RenderTarget9 **outRT)
+{
+    RenderTargetD3D *renderTarget = NULL;
+    gl::Error error = rx::GetAttachmentRenderTarget(attachment, &renderTarget);
+    if (error.isError())
+    {
+        return error;
+    }
+    *outRT = GetAs<RenderTarget9>(renderTarget);
+    return gl::Error(GL_NO_ERROR);
+}
+
 Workarounds GenerateWorkarounds()
 {
     Workarounds workarounds;

src/libANGLE/renderer/d3d/d3d9/renderer9_utils.h

@@ -76,6 +76,7 @@ inline bool isDeviceLostError(HRESULT errorCode)
     }
 }
 
+gl::Error GetAttachmentRenderTarget(const gl::FramebufferAttachment *attachment, RenderTarget9 **outRT);
 Workarounds GenerateWorkarounds();
 
 }

src/libANGLE/renderer/gl/RenderbufferGL.h

@@ -33,12 +33,6 @@ class RenderbufferGL : public RenderbufferImpl
 
     GLuint getRenderbufferID() const;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                        FramebufferAttachmentRenderTarget **rtOut) override
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Not supported on OpenGL");
-    }
-
   private:
     const FunctionsGL *mFunctions;
     StateManagerGL *mStateManager;

src/libANGLE/renderer/gl/SurfaceGL.h

@@ -20,12 +20,6 @@ class SurfaceGL : public SurfaceImpl
     SurfaceGL();
     ~SurfaceGL() override;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                        FramebufferAttachmentRenderTarget **rtOut) override
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Not supported on OpenGL");
-    }
-
     virtual egl::Error makeCurrent() = 0;
 };
 

src/libANGLE/renderer/gl/TextureGL.h

@@ -51,12 +51,6 @@ class TextureGL : public TextureImpl
     void syncSamplerState(const gl::SamplerState &samplerState) const;
     GLuint getTextureID() const;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
-                                        FramebufferAttachmentRenderTarget **rtOut) override
-    {
-        return gl::Error(GL_OUT_OF_MEMORY, "Not supported on OpenGL");
-    }
-
   private:
     GLenum mTextureType;