Stop using FramebufferAttachment::Target.

src/libANGLE/Framebuffer.cpp

@@ -1152,8 +1152,7 @@ void Framebuffer::setAttachmentImpl(GLenum type,
             FramebufferAttachmentObject *attachmentObj = resource;
             if (resource)
             {
-                FramebufferAttachment::Target target(binding, textureIndex);
-                const Format &format = resource->getAttachmentFormat(target);
+                const Format &format = resource->getAttachmentFormat(binding, textureIndex);
                 if (format.info->depthBits == 0 || format.info->stencilBits == 0)
                 {
                     // Attaching nullptr detaches the current attachment.

src/libANGLE/FramebufferAttachment.cpp

@@ -236,10 +236,11 @@ bool FramebufferAttachment::operator!=(const FramebufferAttachment &other) const
 }
 
 Error FramebufferAttachmentObject::getAttachmentRenderTarget(
-    const FramebufferAttachment::Target &target,
+    GLenum binding,
+    const ImageIndex &imageIndex,
     rx::FramebufferAttachmentRenderTarget **rtOut) const
 {
-    return getAttachmentImpl()->getAttachmentRenderTarget(target, rtOut);
+    return getAttachmentImpl()->getAttachmentRenderTarget(binding, imageIndex, rtOut);
 }
 
 angle::BroadcastChannel<> *FramebufferAttachmentObject::getDirtyChannel()

src/libANGLE/FramebufferAttachment.h

@@ -64,28 +64,6 @@ class FramebufferAttachment final
 
     ~FramebufferAttachment();
 
-    // A framebuffer attachment points to one of three types of resources: Renderbuffers,
-    // Textures and egl::Surface. The "Target" struct indicates which part of the
-    // object an attachment references. For the three types:
-    //   - a Renderbuffer has a unique renderable target, and needs no target index
-    //   - a Texture has targets for every image and uses an ImageIndex
-    //   - a Surface has targets for Color and Depth/Stencil, and uses the attachment binding
-    class Target
-    {
-      public:
-        Target();
-        Target(GLenum binding, const ImageIndex &imageIndex);
-        Target(const Target &other);
-        Target &operator=(const Target &other);
-
-        GLenum binding() const { return mBinding; }
-        const ImageIndex &textureIndex() const { return mTextureIndex; }
-
-      private:
-        GLenum mBinding;
-        ImageIndex mTextureIndex;
-    };
-
     void detach();
     void attach(GLenum type,
                 GLenum binding,
@@ -144,6 +122,28 @@ class FramebufferAttachment final
   private:
     gl::Error getRenderTargetImpl(rx::FramebufferAttachmentRenderTarget **rtOut) const;
 
+    // A framebuffer attachment points to one of three types of resources: Renderbuffers,
+    // Textures and egl::Surface. The "Target" struct indicates which part of the
+    // object an attachment references. For the three types:
+    //   - a Renderbuffer has a unique renderable target, and needs no target index
+    //   - a Texture has targets for every image and uses an ImageIndex
+    //   - a Surface has targets for Color and Depth/Stencil, and uses the attachment binding
+    class Target
+    {
+      public:
+        Target();
+        Target(GLenum binding, const ImageIndex &imageIndex);
+        Target(const Target &other);
+        Target &operator=(const Target &other);
+
+        GLenum binding() const { return mBinding; }
+        const ImageIndex &textureIndex() const { return mTextureIndex; }
+
+      private:
+        GLenum mBinding;
+        ImageIndex mTextureIndex;
+    };
+
     GLenum mType;
     Target mTarget;
     FramebufferAttachmentObject *mResource;
@@ -156,16 +156,17 @@ class FramebufferAttachmentObject
     FramebufferAttachmentObject() {}
     virtual ~FramebufferAttachmentObject() {}
 
-    virtual Extents getAttachmentSize(const FramebufferAttachment::Target &target) const = 0;
-    virtual const Format &getAttachmentFormat(
-        const FramebufferAttachment::Target &target) const                                  = 0;
-    virtual GLsizei getAttachmentSamples(const FramebufferAttachment::Target &target) const = 0;
+    virtual Extents getAttachmentSize(const ImageIndex &imageIndex) const = 0;
+    virtual const Format &getAttachmentFormat(GLenum binding,
+                                              const ImageIndex &imageIndex) const = 0;
+    virtual GLsizei getAttachmentSamples(const ImageIndex &imageIndex) const      = 0;
 
     virtual void onAttach() = 0;
     virtual void onDetach() = 0;
     virtual GLuint getId() const = 0;
 
-    Error getAttachmentRenderTarget(const FramebufferAttachment::Target &target,
+    Error getAttachmentRenderTarget(GLenum binding,
+                                    const ImageIndex &imageIndex,
                                     rx::FramebufferAttachmentRenderTarget **rtOut) const;
 
     angle::BroadcastChannel<> *getDirtyChannel();
@@ -179,26 +180,26 @@ class FramebufferAttachmentObject
 inline Extents FramebufferAttachment::getSize() const
 {
     ASSERT(mResource);
-    return mResource->getAttachmentSize(mTarget);
+    return mResource->getAttachmentSize(mTarget.textureIndex());
 }
 
 inline const Format &FramebufferAttachment::getFormat() const
 {
     ASSERT(mResource);
-    return mResource->getAttachmentFormat(mTarget);
+    return mResource->getAttachmentFormat(mTarget.binding(), mTarget.textureIndex());
 }
 
 inline GLsizei FramebufferAttachment::getSamples() const
 {
     ASSERT(mResource);
-    return mResource->getAttachmentSamples(mTarget);
+    return mResource->getAttachmentSamples(mTarget.textureIndex());
 }
 
 inline gl::Error FramebufferAttachment::getRenderTargetImpl(
     rx::FramebufferAttachmentRenderTarget **rtOut) const
 {
     ASSERT(mResource);
-    return mResource->getAttachmentRenderTarget(mTarget, rtOut);
+    return mResource->getAttachmentRenderTarget(mTarget.binding(), mTarget.textureIndex(), rtOut);
 }
 
 } // namespace gl

src/libANGLE/Renderbuffer.cpp

@@ -166,7 +166,7 @@ GLuint Renderbuffer::getId() const
     return id();
 }
 
-Extents Renderbuffer::getAttachmentSize(const FramebufferAttachment::Target & /*target*/) const
+Extents Renderbuffer::getAttachmentSize(const gl::ImageIndex & /*imageIndex*/) const
 {
     return Extents(mWidth, mHeight, 1);
 }

src/libANGLE/Renderbuffer.h

@@ -58,13 +58,16 @@ class Renderbuffer final : public egl::ImageSibling,
     GLuint getStencilSize() const;
 
     // FramebufferAttachmentObject Impl
-    Extents getAttachmentSize(const FramebufferAttachment::Target &target) const override;
-    const Format &getAttachmentFormat(
-        const FramebufferAttachment::Target & /*target*/) const override
+    Extents getAttachmentSize(const ImageIndex &imageIndex) const override;
+    const Format &getAttachmentFormat(GLenum /*binding*/,
+                                      const ImageIndex & /*imageIndex*/) const override
     {
         return getFormat();
     }
-    GLsizei getAttachmentSamples(const FramebufferAttachment::Target &/*target*/) const override { return getSamples(); }
+    GLsizei getAttachmentSamples(const ImageIndex & /*imageIndex*/) const override
+    {
+        return getSamples();
+    }
 
     void onAttach() override;
     void onDetach() override;

src/libANGLE/Surface.cpp

@@ -255,18 +255,17 @@ void Surface::releaseTexImageFromTexture()
     mTexture.set(nullptr);
 }
 
-gl::Extents Surface::getAttachmentSize(const gl::FramebufferAttachment::Target & /*target*/) const
+gl::Extents Surface::getAttachmentSize(const gl::ImageIndex & /*target*/) const
 {
     return gl::Extents(getWidth(), getHeight(), 1);
 }
 
-const gl::Format &Surface::getAttachmentFormat(
-    const gl::FramebufferAttachment::Target &target) const
+const gl::Format &Surface::getAttachmentFormat(GLenum binding, const gl::ImageIndex &target) const
 {
-    return (target.binding() == GL_BACK ? mBackFormat : mDSFormat);
+    return (binding == GL_BACK ? mBackFormat : mDSFormat);
 }
 
-GLsizei Surface::getAttachmentSamples(const gl::FramebufferAttachment::Target &target) const
+GLsizei Surface::getAttachmentSamples(const gl::ImageIndex &target) const
 {
     return getConfig()->samples;
 }

src/libANGLE/Surface.h

@@ -87,10 +87,10 @@ class Surface : public gl::FramebufferAttachmentObject
     EGLint isFixedSize() const;
 
     // FramebufferAttachmentObject implementation
-    gl::Extents getAttachmentSize(const gl::FramebufferAttachment::Target &target) const override;
-    const gl::Format &getAttachmentFormat(
-        const gl::FramebufferAttachment::Target &target) const override;
-    GLsizei getAttachmentSamples(const gl::FramebufferAttachment::Target &target) const override;
+    gl::Extents getAttachmentSize(const gl::ImageIndex &imageIndex) const override;
+    const gl::Format &getAttachmentFormat(GLenum binding,
+                                          const gl::ImageIndex &imageIndex) const override;
+    GLsizei getAttachmentSamples(const gl::ImageIndex &imageIndex) const override;
 
     void onAttach() override {}
     void onDetach() override {}

src/libANGLE/Surface_unittest.cpp

@@ -43,7 +43,10 @@ class MockSurfaceImpl : public rx::SurfaceImpl
     MOCK_CONST_METHOD0(getHeight, EGLint());
     MOCK_CONST_METHOD0(isPostSubBufferSupported, EGLint(void));
     MOCK_CONST_METHOD0(getSwapBehavior, EGLint(void));
-    MOCK_METHOD2(getAttachmentRenderTarget, gl::Error(const gl::FramebufferAttachment::Target &, rx::FramebufferAttachmentRenderTarget **));
+    MOCK_METHOD3(getAttachmentRenderTarget,
+                 gl::Error(GLenum,
+                           const gl::ImageIndex &,
+                           rx::FramebufferAttachmentRenderTarget **));
 
     MOCK_METHOD0(destructor, void());
 

src/libANGLE/Texture.cpp

@@ -1239,19 +1239,19 @@ Error Texture::setEGLImageTarget(GLenum target, egl::Image *imageTarget)
     return NoError();
 }
 
-Extents Texture::getAttachmentSize(const FramebufferAttachment::Target &target) const
+Extents Texture::getAttachmentSize(const ImageIndex &imageIndex) const
 {
-    return mState.getImageDesc(target.textureIndex()).size;
+    return mState.getImageDesc(imageIndex).size;
 }
 
-const Format &Texture::getAttachmentFormat(const FramebufferAttachment::Target &target) const
+const Format &Texture::getAttachmentFormat(GLenum /*binding*/, const ImageIndex &imageIndex) const
 {
-    return mState.getImageDesc(target.textureIndex()).format;
+    return mState.getImageDesc(imageIndex).format;
 }
 
-GLsizei Texture::getAttachmentSamples(const FramebufferAttachment::Target &target) const
+GLsizei Texture::getAttachmentSamples(const ImageIndex &imageIndex) const
 {
-    return getSamples(target.textureIndex().type, 0);
+    return getSamples(imageIndex.type, 0);
 }
 
 void Texture::onAttach()

src/libANGLE/Texture.h

@@ -358,9 +358,9 @@ class Texture final : public egl::ImageSibling,
     rx::TextureImpl *getImplementation() const { return mTexture; }
 
     // FramebufferAttachmentObject implementation
-    Extents getAttachmentSize(const FramebufferAttachment::Target &target) const override;
-    const Format &getAttachmentFormat(const FramebufferAttachment::Target &target) const override;
-    GLsizei getAttachmentSamples(const FramebufferAttachment::Target &target) const override;
+    Extents getAttachmentSize(const ImageIndex &imageIndex) const override;
+    const Format &getAttachmentFormat(GLenum binding, const ImageIndex &imageIndex) const override;
+    GLsizei getAttachmentSamples(const ImageIndex &imageIndex) const override;
 
     void onAttach() override;
     void onDetach() override;

src/libANGLE/renderer/FramebufferAttachmentObjectImpl.h

@@ -22,11 +22,12 @@ class FramebufferAttachmentObjectImpl : angle::NonCopyable
     FramebufferAttachmentObjectImpl() {}
     virtual ~FramebufferAttachmentObjectImpl() {}
 
-    virtual gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+    virtual gl::Error getAttachmentRenderTarget(GLenum binding,
+                                                const gl::ImageIndex &imageIndex,
                                                 FramebufferAttachmentRenderTarget **rtOut)
     {
         UNIMPLEMENTED();
-        return gl::Error(GL_OUT_OF_MEMORY, "getAttachmentRenderTarget not supported.");
+        return gl::OutOfMemory() << "getAttachmentRenderTarget not supported.";
     }
 };
 

src/libANGLE/renderer/RenderbufferImpl_mock.h

@@ -25,7 +25,8 @@ class MockRenderbufferImpl : public RenderbufferImpl
     MOCK_METHOD4(setStorageMultisample, gl::Error(size_t, GLenum, size_t, size_t));
     MOCK_METHOD1(setStorageEGLImageTarget, gl::Error(egl::Image *));
 
-    MOCK_METHOD2(getAttachmentRenderTarget, gl::Error(const gl::FramebufferAttachment::Target &, FramebufferAttachmentRenderTarget **));
+    MOCK_METHOD3(getAttachmentRenderTarget,
+                 gl::Error(GLenum, const gl::ImageIndex &, FramebufferAttachmentRenderTarget **));
 
     MOCK_METHOD0(destructor, void());
 };

src/libANGLE/renderer/TextureImpl_mock.h

@@ -103,7 +103,8 @@ class MockTextureImpl : public TextureImpl
     MOCK_METHOD1(bindTexImage, void(egl::Surface *));
     MOCK_METHOD0(releaseTexImage, void(void));
 
-    MOCK_METHOD2(getAttachmentRenderTarget, gl::Error(const gl::FramebufferAttachment::Target &, FramebufferAttachmentRenderTarget **));
+    MOCK_METHOD3(getAttachmentRenderTarget,
+                 gl::Error(GLenum, const gl::ImageIndex &, FramebufferAttachmentRenderTarget **));
 
     MOCK_METHOD6(setStorageMultisample,
                  gl::Error(ContextImpl *, GLenum, GLsizei, GLint, const gl::Extents &, GLboolean));

src/libANGLE/renderer/d3d/EGLImageD3D.cpp

@@ -39,7 +39,11 @@ EGLImageD3D::EGLImageD3D(RendererD3D *renderer,
                          EGLenum target,
                          egl::ImageSibling *buffer,
                          const egl::AttributeMap &attribs)
-    : mRenderer(renderer), mBuffer(buffer), mAttachmentBuffer(nullptr), mRenderTarget(nullptr)
+    : mRenderer(renderer),
+      mBuffer(buffer),
+      mImageIndex(gl::ImageIndex::MakeInvalid()),
+      mAttachmentBuffer(nullptr),
+      mRenderTarget(nullptr)
 {
     ASSERT(renderer != nullptr);
     ASSERT(buffer != nullptr);
@@ -47,16 +51,13 @@ EGLImageD3D::EGLImageD3D(RendererD3D *renderer,
     if (egl::IsTextureTarget(target))
     {
         mAttachmentBuffer = GetImplAs<TextureD3D>(GetAs<gl::Texture>(buffer));
-        mAttachmentTarget = gl::FramebufferAttachment::Target(
-            GL_NONE, GetImageIndex(egl_gl::EGLImageTargetToGLTextureTarget(target),
-                                   attribs.get(EGL_GL_TEXTURE_LEVEL_KHR, 0),
-                                   attribs.get(EGL_GL_TEXTURE_ZOFFSET_KHR, 0)));
+        mImageIndex       = GetImageIndex(egl_gl::EGLImageTargetToGLTextureTarget(target),
+                                    attribs.get(EGL_GL_TEXTURE_LEVEL_KHR, 0),
+                                    attribs.get(EGL_GL_TEXTURE_ZOFFSET_KHR, 0));
     }
     else if (egl::IsRenderbufferTarget(target))
     {
         mAttachmentBuffer = GetImplAs<RenderbufferD3D>(GetAs<gl::Renderbuffer>(buffer));
-        mAttachmentTarget =
-            gl::FramebufferAttachment::Target(GL_NONE, gl::ImageIndex::MakeInvalid());
     }
     else
     {
@@ -78,11 +79,7 @@ gl::Error EGLImageD3D::orphan(egl::ImageSibling *sibling)
 {
     if (sibling == mBuffer)
     {
-        gl::Error error = copyToLocalRendertarget();
-        if (error.isError())
-        {
-            return error;
-        }
+        ANGLE_TRY(copyToLocalRendertarget());
     }
 
     return gl::NoError();
@@ -93,12 +90,7 @@ gl::Error EGLImageD3D::getRenderTarget(RenderTargetD3D **outRT) const
     if (mAttachmentBuffer)
     {
         FramebufferAttachmentRenderTarget *rt = nullptr;
-        gl::Error error = mAttachmentBuffer->getAttachmentRenderTarget(mAttachmentTarget, &rt);
-        if (error.isError())
-        {
-            return error;
-        }
-
+        ANGLE_TRY(mAttachmentBuffer->getAttachmentRenderTarget(GL_NONE, mImageIndex, &rt));
         *outRT = static_cast<RenderTargetD3D *>(rt);
         return gl::NoError();
     }
@@ -117,11 +109,7 @@ gl::Error EGLImageD3D::copyToLocalRendertarget()
     ASSERT(mRenderTarget == nullptr);
 
     RenderTargetD3D *curRenderTarget = nullptr;
-    gl::Error error = getRenderTarget(&curRenderTarget);
-    if (error.isError())
-    {
-        return error;
-    }
+    ANGLE_TRY(getRenderTarget(&curRenderTarget));
 
     // This only currently applies do D3D11, where it invalidates FBOs with this Image attached.
     curRenderTarget->signalDirty();
@@ -132,4 +120,4 @@ gl::Error EGLImageD3D::copyToLocalRendertarget()
 
     return mRenderer->createRenderTargetCopy(curRenderTarget, &mRenderTarget);
 }
-}
+}  // namespace rx

src/libANGLE/renderer/d3d/EGLImageD3D.h

@@ -46,7 +46,7 @@ class EGLImageD3D final : public ImageImpl
 
     egl::ImageSibling *mBuffer;
 
-    gl::FramebufferAttachment::Target mAttachmentTarget;
+    gl::ImageIndex mImageIndex;
     FramebufferAttachmentObjectImpl *mAttachmentBuffer;
 
     RenderTargetD3D *mRenderTarget;

src/libANGLE/renderer/d3d/RenderbufferD3D.cpp

@@ -87,7 +87,8 @@ gl::Error RenderbufferD3D::getRenderTarget(RenderTargetD3D **outRenderTarget)
     }
 }
 
-gl::Error RenderbufferD3D::getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+gl::Error RenderbufferD3D::getAttachmentRenderTarget(GLenum /*binding*/,
+                                                     const gl::ImageIndex & /*imageIndex*/,
                                                      FramebufferAttachmentRenderTarget **rtOut)
 {
     return getRenderTarget(reinterpret_cast<RenderTargetD3D **>(rtOut));

src/libANGLE/renderer/d3d/RenderbufferD3D.h

@@ -35,7 +35,8 @@ class RenderbufferD3D : public RenderbufferImpl
     gl::Error setStorageEGLImageTarget(egl::Image *image) override;
 
     gl::Error getRenderTarget(RenderTargetD3D **outRenderTarget);
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+    gl::Error getAttachmentRenderTarget(GLenum binding,
+                                        const gl::ImageIndex &imageIndex,
                                         FramebufferAttachmentRenderTarget **rtOut) override;
 
   private:

src/libANGLE/renderer/d3d/SurfaceD3D.cpp

@@ -345,10 +345,11 @@ egl::Error SurfaceD3D::querySurfacePointerANGLE(EGLint attribute, void **value)
     return egl::Error(EGL_SUCCESS);
 }
 
-gl::Error SurfaceD3D::getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+gl::Error SurfaceD3D::getAttachmentRenderTarget(GLenum binding,
+                                                const gl::ImageIndex &imageIndex,
                                                 FramebufferAttachmentRenderTarget **rtOut)
 {
-    if (target.binding() == GL_BACK)
+    if (binding == GL_BACK)
     {
         *rtOut = mSwapChain->getColorRenderTarget();
     }

src/libANGLE/renderer/d3d/SurfaceD3D.h

@@ -53,7 +53,8 @@ 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,
+    gl::Error getAttachmentRenderTarget(GLenum binding,
+                                        const gl::ImageIndex &imageIndex,
                                         FramebufferAttachmentRenderTarget **rtOut) override;
 
   protected:

src/libANGLE/renderer/d3d/TextureD3D.cpp

@@ -536,11 +536,12 @@ gl::Error TextureD3D::commitRegion(const gl::ImageIndex &index, const gl::Box &r
     return gl::NoError();
 }
 
-gl::Error TextureD3D::getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+gl::Error TextureD3D::getAttachmentRenderTarget(GLenum /*binding*/,
+                                                const gl::ImageIndex &imageIndex,
                                                 FramebufferAttachmentRenderTarget **rtOut)
 {
     RenderTargetD3D *rtD3D = nullptr;
-    gl::Error error = getRenderTarget(target.textureIndex(), &rtD3D);
+    gl::Error error        = getRenderTarget(imageIndex, &rtD3D);
     *rtOut = static_cast<FramebufferAttachmentRenderTarget *>(rtD3D);
     return error;
 }

src/libANGLE/renderer/d3d/TextureD3D.h

@@ -71,7 +71,8 @@ class TextureD3D : public TextureImpl
     TextureStorage *getStorage();
     ImageD3D *getBaseLevelImage() const;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+    gl::Error getAttachmentRenderTarget(GLenum binding,
+                                        const gl::ImageIndex &imageIndex,
                                         FramebufferAttachmentRenderTarget **rtOut) override;
 
     void setBaseLevel(GLuint baseLevel) override;

src/libANGLE/renderer/vulkan/RenderbufferVk.cpp

@@ -43,7 +43,8 @@ gl::Error RenderbufferVk::setStorageEGLImageTarget(egl::Image *image)
     return gl::Error(GL_INVALID_OPERATION);
 }
 
-gl::Error RenderbufferVk::getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+gl::Error RenderbufferVk::getAttachmentRenderTarget(GLenum binding,
+                                                    const gl::ImageIndex &imageIndex,
                                                     FramebufferAttachmentRenderTarget **rtOut)
 {
     UNIMPLEMENTED();

src/libANGLE/renderer/vulkan/RenderbufferVk.h

@@ -28,7 +28,8 @@ class RenderbufferVk : public RenderbufferImpl
                                     size_t height) override;
     gl::Error setStorageEGLImageTarget(egl::Image *image) override;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+    gl::Error getAttachmentRenderTarget(GLenum binding,
+                                        const gl::ImageIndex &imageIndex,
                                         FramebufferAttachmentRenderTarget **rtOut) override;
 };
 

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -137,7 +137,8 @@ EGLint OffscreenSurfaceVk::getSwapBehavior() const
 }
 
 gl::Error OffscreenSurfaceVk::getAttachmentRenderTarget(
-    const gl::FramebufferAttachment::Target & /*target*/,
+    GLenum /*binding*/,
+    const gl::ImageIndex & /*imageIndex*/,
     FramebufferAttachmentRenderTarget ** /*rtOut*/)
 {
     UNREACHABLE();
@@ -529,9 +530,9 @@ EGLint WindowSurfaceVk::getSwapBehavior() const
     return EGL_BUFFER_DESTROYED;
 }
 
-gl::Error WindowSurfaceVk::getAttachmentRenderTarget(
-    const gl::FramebufferAttachment::Target & /*target*/,
-    FramebufferAttachmentRenderTarget **rtOut)
+gl::Error WindowSurfaceVk::getAttachmentRenderTarget(GLenum /*binding*/,
+                                                     const gl::ImageIndex & /*target*/,
+                                                     FramebufferAttachmentRenderTarget **rtOut)
 {
     *rtOut = &mRenderTarget;
     return gl::NoError();

src/libANGLE/renderer/vulkan/SurfaceVk.h

@@ -43,7 +43,8 @@ class OffscreenSurfaceVk : public SurfaceImpl
     EGLint isPostSubBufferSupported() const override;
     EGLint getSwapBehavior() const override;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+    gl::Error getAttachmentRenderTarget(GLenum binding,
+                                        const gl::ImageIndex &imageIndex,
                                         FramebufferAttachmentRenderTarget **rtOut) override;
 
   private:
@@ -79,7 +80,8 @@ class WindowSurfaceVk : public SurfaceImpl, public ResourceVk
     EGLint isPostSubBufferSupported() const override;
     EGLint getSwapBehavior() const override;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+    gl::Error getAttachmentRenderTarget(GLenum binding,
+                                        const gl::ImageIndex &imageIndex,
                                         FramebufferAttachmentRenderTarget **rtOut) override;
 
     gl::ErrorOrResult<vk::Framebuffer *> getCurrentFramebuffer(

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -142,7 +142,8 @@ void TextureVk::releaseTexImage()
     UNIMPLEMENTED();
 }
 
-gl::Error TextureVk::getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+gl::Error TextureVk::getAttachmentRenderTarget(GLenum binding,
+                                               const gl::ImageIndex &imageIndex,
                                                FramebufferAttachmentRenderTarget **rtOut)
 {
     UNIMPLEMENTED();

src/libANGLE/renderer/vulkan/TextureVk.h

@@ -88,7 +88,8 @@ class TextureVk : public TextureImpl
     void bindTexImage(egl::Surface *surface) override;
     void releaseTexImage() override;
 
-    gl::Error getAttachmentRenderTarget(const gl::FramebufferAttachment::Target &target,
+    gl::Error getAttachmentRenderTarget(GLenum binding,
+                                        const gl::ImageIndex &imageIndex,
                                         FramebufferAttachmentRenderTarget **rtOut) override;
 
     void syncState(const gl::Texture::DirtyBits &dirtyBits) override;