Vulkan: Get rid of "fetch" level/layer image views.

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -821,7 +821,7 @@ angle::Result FramebufferVk::blit(const gl::Context *context,
         else
         {
             ANGLE_TRY(utilsVk.colorBlitResolve(contextVk, this, &readRenderTarget->getImage(),
-                                               readRenderTarget->getFetchImageView(), params));
+                                               readRenderTarget->getReadImageView(), params));
         }
     }
 

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -18,11 +18,7 @@
 namespace rx
 {
 RenderTargetVk::RenderTargetVk()
-    : mImage(nullptr),
-      mImageView(nullptr),
-      mCubeImageFetchView(nullptr),
-      mLevelIndex(0),
-      mLayerIndex(0)
+    : mImage(nullptr), mImageView(nullptr), mLevelIndex(0), mLayerIndex(0)
 {}
 
 RenderTargetVk::~RenderTargetVk() {}
@@ -30,31 +26,27 @@ RenderTargetVk::~RenderTargetVk() {}
 RenderTargetVk::RenderTargetVk(RenderTargetVk &&other)
     : mImage(other.mImage),
       mImageView(other.mImageView),
-      mCubeImageFetchView(other.mCubeImageFetchView),
       mLevelIndex(other.mLevelIndex),
       mLayerIndex(other.mLayerIndex)
 {}
 
 void RenderTargetVk::init(vk::ImageHelper *image,
                           const vk::ImageView *imageView,
-                          const vk::ImageView *cubeImageFetchView,
                           uint32_t levelIndex,
                           uint32_t layerIndex)
 {
-    mImage              = image;
-    mImageView          = imageView;
-    mCubeImageFetchView = cubeImageFetchView;
-    mLevelIndex         = levelIndex;
-    mLayerIndex         = layerIndex;
+    mImage      = image;
+    mImageView  = imageView;
+    mLevelIndex = levelIndex;
+    mLayerIndex = layerIndex;
 }
 
 void RenderTargetVk::reset()
 {
-    mImage              = nullptr;
-    mImageView          = nullptr;
-    mCubeImageFetchView = nullptr;
-    mLevelIndex         = 0;
-    mLayerIndex         = 0;
+    mImage      = nullptr;
+    mImageView  = nullptr;
+    mLevelIndex = 0;
+    mLayerIndex = 0;
 }
 
 angle::Result RenderTargetVk::onColorDraw(ContextVk *contextVk,
@@ -116,12 +108,6 @@ const vk::ImageView *RenderTargetVk::getReadImageView() const
     return getDrawImageView();
 }
 
-const vk::ImageView *RenderTargetVk::getFetchImageView() const
-{
-    return mCubeImageFetchView && mCubeImageFetchView->valid() ? mCubeImageFetchView
-                                                               : getReadImageView();
-}
-
 const vk::Format &RenderTargetVk::getImageFormat() const
 {
     ASSERT(mImage && mImage->valid());
@@ -137,9 +123,8 @@ gl::Extents RenderTargetVk::getExtents() const
 void RenderTargetVk::updateSwapchainImage(vk::ImageHelper *image, const vk::ImageView *imageView)
 {
     ASSERT(image && image->valid() && imageView && imageView->valid());
-    mImage              = image;
-    mImageView          = imageView;
-    mCubeImageFetchView = nullptr;
+    mImage     = image;
+    mImageView = imageView;
 }
 
 vk::ImageHelper *RenderTargetVk::getImageForRead(ContextVk *contextVk,

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -45,7 +45,6 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
 
     void init(vk::ImageHelper *image,
               const vk::ImageView *imageView,
-              const vk::ImageView *cubeImageFetchView,
               uint32_t levelIndex,
               uint32_t layerIndex);
     void reset();
@@ -71,10 +70,6 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
 
     const vk::ImageView *getDrawImageView() const;
     const vk::ImageView *getReadImageView() const;
-    // GLSL's texelFetch() needs a 2D array view to read from cube maps.  This function returns the
-    // same view as `getReadImageView()`, except for cubemaps, in which case it returns a 2D array
-    // view of it.
-    const vk::ImageView *getFetchImageView() const;
 
     const vk::Format &getImageFormat() const;
     gl::Extents getExtents() const;
@@ -90,10 +85,8 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
   private:
     vk::ImageHelper *mImage;
     // Note that the draw and read image views are the same, given the requirements of a render
-    // target.
+    // target. Note that for cube maps we use 2D array views.
     const vk::ImageView *mImageView;
-    // For cubemaps, a 2D-array view is also created to be used with shaders that use texelFetch().
-    const vk::ImageView *mCubeImageFetchView;
     uint32_t mLevelIndex;
     uint32_t mLayerIndex;
 };

src/libANGLE/renderer/vulkan/RenderbufferVk.cpp

@@ -88,7 +88,7 @@ angle::Result RenderbufferVk::setStorageImpl(const gl::Context *context,
         // Clear the renderbuffer if it has emulated channels.
         mImage->stageClearIfEmulatedFormat(gl::ImageIndex::Make2D(0), vkFormat);
 
-        mRenderTarget.init(mImage, &mImageView, nullptr, 0, 0);
+        mRenderTarget.init(mImage, &mImageView, 0, 0);
     }
 
     return angle::Result::Continue;
@@ -168,22 +168,19 @@ angle::Result RenderbufferVk::setStorageEGLImageTarget(const gl::Context *contex
                                      rendererQueueFamilyIndex, commandBuffer);
     }
 
-    ANGLE_TRY(mImage->initLayerImageView(contextVk, imageVk->getImageTextureType(), aspect,
-                                         gl::SwizzleState(), &mImageView, imageVk->getImageLevel(),
-                                         1, imageVk->getImageLayer(), 1));
+    gl::TextureType viewType = imageVk->getImageTextureType();
 
     if (imageVk->getImageTextureType() == gl::TextureType::CubeMap)
     {
-        gl::TextureType arrayType = vk::Get2DTextureType(imageVk->getImage()->getLayerCount(),
-                                                         imageVk->getImage()->getSamples());
-        ANGLE_TRY(mImage->initLayerImageView(contextVk, arrayType, aspect, gl::SwizzleState(),
-                                             &mCubeImageFetchView, imageVk->getImageLevel(), 1,
-                                             imageVk->getImageLayer(), 1));
+        viewType = vk::Get2DTextureType(imageVk->getImage()->getLayerCount(),
+                                        imageVk->getImage()->getSamples());
     }
 
-    mRenderTarget.init(mImage, &mImageView,
-                       mCubeImageFetchView.valid() ? &mCubeImageFetchView : nullptr,
-                       imageVk->getImageLevel(), imageVk->getImageLayer());
+    ANGLE_TRY(mImage->initLayerImageView(contextVk, viewType, aspect, gl::SwizzleState(),
+                                         &mImageView, imageVk->getImageLevel(), 1,
+                                         imageVk->getImageLayer(), 1));
+
+    mRenderTarget.init(mImage, &mImageView, imageVk->getImageLevel(), imageVk->getImageLayer());
 
     return angle::Result::Continue;
 }
@@ -236,7 +233,6 @@ void RenderbufferVk::releaseImage(ContextVk *contextVk)
     }
 
     contextVk->addGarbage(&mImageView);
-    contextVk->addGarbage(&mCubeImageFetchView);
 }
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/RenderbufferVk.h

@@ -61,7 +61,6 @@ class RenderbufferVk : public RenderbufferImpl
     bool mOwnsImage;
     vk::ImageHelper *mImage;
     vk::ImageView mImageView;
-    vk::ImageView mCubeImageFetchView;
     RenderTargetVk mRenderTarget;
 };
 

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -177,9 +177,9 @@ OffscreenSurfaceVk::OffscreenSurfaceVk(const egl::SurfaceState &surfaceState,
                                        EGLint height)
     : SurfaceVk(surfaceState), mWidth(width), mHeight(height)
 {
-    mColorRenderTarget.init(&mColorAttachment.image, &mColorAttachment.imageView, nullptr, 0, 0);
+    mColorRenderTarget.init(&mColorAttachment.image, &mColorAttachment.imageView, 0, 0);
     mDepthStencilRenderTarget.init(&mDepthStencilAttachment.image,
-                                   &mDepthStencilAttachment.imageView, nullptr, 0, 0);
+                                   &mDepthStencilAttachment.imageView, 0, 0);
 }
 
 OffscreenSurfaceVk::~OffscreenSurfaceVk() {}
@@ -408,8 +408,8 @@ WindowSurfaceVk::WindowSurfaceVk(const egl::SurfaceState &surfaceState,
 {
     // Initialize the color render target with the multisampled targets.  If not multisampled, the
     // render target will be updated to refer to a swapchain image on every acquire.
-    mColorRenderTarget.init(&mColorImageMS, &mColorImageViewMS, nullptr, 0, 0);
-    mDepthStencilRenderTarget.init(&mDepthStencilImage, &mDepthStencilImageView, nullptr, 0, 0);
+    mColorRenderTarget.init(&mColorImageMS, &mColorImageViewMS, 0, 0);
+    mDepthStencilRenderTarget.init(&mDepthStencilImage, &mDepthStencilImageView, 0, 0);
 }
 
 WindowSurfaceVk::~WindowSurfaceVk()

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -470,7 +470,7 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,
 
         return copySubImageImplWithDraw(contextVk, offsetImageIndex, modifiedDestOffset, destFormat,
                                         0, clippedSourceArea, isViewportFlipY, false, false, false,
-                                        &colorReadRT->getImage(), colorReadRT->getFetchImageView());
+                                        &colorReadRT->getImage(), colorReadRT->getReadImageView());
     }
 
     // Do a CPU readback that does the conversion, and then stage the change to the pixel buffer.
@@ -953,8 +953,8 @@ void TextureVk::setImageHelper(ContextVk *contextVk,
     mImage->initStagingBuffer(contextVk->getRenderer(), format, vk::kStagingBufferFlags,
                               mStagingBufferInitialSize);
 
-    mRenderTarget.init(mImage, &mDefaultViews.mDrawImageView, &mDefaultViews.mFetchImageView,
-                       getNativeImageLevel(0), getNativeImageLayer(0));
+    mRenderTarget.init(mImage, &mDefaultViews.mDrawImageView, getNativeImageLevel(0),
+                       getNativeImageLayer(0));
 
     // Force re-creation of layered render targets next time they are needed
     mLayerRenderTargets.clear();
@@ -1376,29 +1376,13 @@ angle::Result TextureVk::initLayerRenderTargets(ContextVk *contextVk, GLuint lay
     if (!mLayerRenderTargets.empty())
         return angle::Result::Continue;
 
-    const gl::ImageDesc &baseLevelDesc = mState.getBaseLevelDesc();
-
-    mLayerFetchImageView.resize(layerCount);
     mLayerRenderTargets.resize(layerCount);
 
     for (uint32_t layerIndex = 0; layerIndex < layerCount; ++layerIndex)
     {
         const vk::ImageView *drawView;
         ANGLE_TRY(getLayerLevelDrawImageView(contextVk, layerIndex, 0, &drawView));
-
-        // Users of the render target expect the views to directly view the desired layer, so we
-        // need create a fetch view for each layer as well.
-        gl::SwizzleState mappedSwizzle;
-        MapSwizzleState(contextVk, mImage->getFormat(), baseLevelDesc.format.info->sized,
-                        mState.getSwizzleState(), &mappedSwizzle);
-        gl::TextureType arrayType = vk::Get2DTextureType(layerCount, mImage->getSamples());
-        ANGLE_TRY(mImage->initLayerImageView(contextVk, arrayType, mImage->getAspectFlags(),
-                                             mappedSwizzle, &mLayerFetchImageView[layerIndex],
-                                             getNativeImageLevel(0), 1,
-                                             getNativeImageLayer(layerIndex), 1));
-
-        mLayerRenderTargets[layerIndex].init(mImage, drawView, &mLayerFetchImageView[layerIndex],
-                                             getNativeImageLevel(0),
+        mLayerRenderTargets[layerIndex].init(mImage, drawView, getNativeImageLevel(0),
                                              getNativeImageLayer(layerIndex));
     }
     return angle::Result::Continue;
@@ -1558,16 +1542,13 @@ const vk::ImageView &TextureVk::getReadImageView() const
 
 const vk::ImageView &TextureVk::getFetchImageView() const
 {
-
-    if (!mDefaultViews.mFetchImageView.valid())
+    ASSERT(mImage->valid());
+    const TextureVkViews *activeViews = getTextureViews();
+    if (activeViews->mFetchImageView.valid())
     {
-        return getReadImageView();
+        return activeViews->mFetchImageView;
     }
-
-    ASSERT(mImage->valid());
-    const TextureVkViews *activeView = getTextureViews();
-
-    return activeView->mFetchImageView;
+    return activeViews->mReadImageView;
 }
 
 vk::ImageView *TextureVk::getLayerLevelImageViewImpl(vk::LayerLevelImageViewVector *imageViews,
@@ -1746,6 +1727,7 @@ angle::Result TextureVk::initImageViewImpl(ContextVk *contextVk,
     ANGLE_TRY(mImage->initLayerImageView(contextVk, mState.getType(), aspectFlags, mappedSwizzle,
                                          &view->mReadImageView, baseLevel, levelCount, baseLayer,
                                          layerCount));
+
     if (mState.getType() == gl::TextureType::CubeMap ||
         mState.getType() == gl::TextureType::_2DArray ||
         mState.getType() == gl::TextureType::_2DMultisampleArray)
@@ -1756,6 +1738,7 @@ angle::Result TextureVk::initImageViewImpl(ContextVk *contextVk,
                                              &view->mFetchImageView, baseLevel, levelCount,
                                              baseLayer, layerCount));
     }
+
     if (!format.imageFormat().isBlock)
     {
         ANGLE_TRY(mImage->initLayerImageView(contextVk, mState.getType(), aspectFlags,
@@ -1824,11 +1807,6 @@ void TextureVk::releaseImageViews(ContextVk *contextVk)
         }
     }
     mLayerLevelDrawImageViews.clear();
-    for (vk::ImageView &imageView : mLayerFetchImageView)
-    {
-        contextVk->addGarbage(&imageView);
-    }
-    mLayerFetchImageView.clear();
     for (vk::ImageView &imageView : mLevelStorageImageViews)
     {
         contextVk->addGarbage(&imageView);

src/libANGLE/renderer/vulkan/TextureVk.h

@@ -354,8 +354,6 @@ class TextureVk : public TextureImpl
     TextureVkViews mStencilViews;
     // Draw views.
     vk::LayerLevelImageViewVector mLayerLevelDrawImageViews;
-    // Fetch views.
-    vk::ImageViewVector mLayerFetchImageView;
     // Storage image views.
     vk::ImageViewVector mLevelStorageImageViews;