Vulkan: Have a cubemap as 2D-array view handy

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -18,7 +18,11 @@
 namespace rx
 {
 RenderTargetVk::RenderTargetVk()
-    : mImage(nullptr), mImageView(nullptr), mLevelIndex(0), mLayerIndex(0)
+    : mImage(nullptr),
+      mImageView(nullptr),
+      mCubeImageFetchView(nullptr),
+      mLevelIndex(0),
+      mLayerIndex(0)
 {}
 
 RenderTargetVk::~RenderTargetVk() {}
@@ -26,17 +30,20 @@ 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,
                           vk::ImageView *imageView,
+                          vk::ImageView *cubeImageFetchView,
                           size_t levelIndex,
                           size_t layerIndex)
 {
     mImage      = image;
     mImageView  = imageView;
+    mCubeImageFetchView = cubeImageFetchView;
     mLevelIndex = levelIndex;
     mLayerIndex = layerIndex;
 }
@@ -45,6 +52,7 @@ void RenderTargetVk::reset()
 {
     mImage      = nullptr;
     mImageView  = nullptr;
+    mCubeImageFetchView = nullptr;
     mLevelIndex = 0;
     mLayerIndex = 0;
 }
@@ -108,6 +116,12 @@ vk::ImageView *RenderTargetVk::getReadImageView() const
     return getDrawImageView();
 }
 
+vk::ImageView *RenderTargetVk::getFetchImageView() const
+{
+    return mCubeImageFetchView && mCubeImageFetchView->valid() ? mCubeImageFetchView
+                                                               : getReadImageView();
+}
+
 const vk::Format &RenderTargetVk::getImageFormat() const
 {
     ASSERT(mImage && mImage->valid());
@@ -125,6 +139,7 @@ void RenderTargetVk::updateSwapchainImage(vk::ImageHelper *image, vk::ImageView
     ASSERT(image && image->valid() && imageView && imageView->valid());
     mImage     = image;
     mImageView = imageView;
+    mCubeImageFetchView = nullptr;
 }
 
 vk::ImageHelper *RenderTargetVk::getImageForRead(vk::CommandGraphResource *readingResource,

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -45,6 +45,7 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
 
     void init(vk::ImageHelper *image,
               vk::ImageView *imageView,
+              vk::ImageView *cubeImageFetchView,
               size_t levelIndex,
               size_t layerIndex);
     void reset();
@@ -68,6 +69,10 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
 
     vk::ImageView *getDrawImageView() 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.
+    vk::ImageView *getFetchImageView() const;
 
     const vk::Format &getImageFormat() const;
     gl::Extents getExtents() const;
@@ -85,6 +90,8 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
     // Note that the draw and read image views are the same, given the requirements of a render
     // target.
     vk::ImageView *mImageView;
+    // For cubemaps, a 2D-array view is also created to be used with shaders that use texelFetch().
+    vk::ImageView *mCubeImageFetchView;
     size_t mLevelIndex;
     size_t mLayerIndex;
 };

src/libANGLE/renderer/vulkan/RenderbufferVk.cpp

@@ -87,7 +87,7 @@ angle::Result RenderbufferVk::setStorage(const gl::Context *context,
         // Clear the renderbuffer if it has emulated channels.
         mImage->clearIfEmulatedFormat(vk::GetImpl(context), gl::ImageIndex::Make2D(0), vkFormat);
 
-        mRenderTarget.init(mImage, &mImageView, 0, 0);
+        mRenderTarget.init(mImage, &mImageView, nullptr, 0, 0);
     }
 
     return angle::Result::Continue;
@@ -134,7 +134,19 @@ angle::Result RenderbufferVk::setStorageEGLImageTarget(const gl::Context *contex
                                          gl::SwizzleState(), &mImageView, imageVk->getImageLevel(),
                                          1, imageVk->getImageLayer(), 1));
 
-    mRenderTarget.init(mImage, &mImageView, imageVk->getImageLevel(), imageVk->getImageLayer());
+    if (imageVk->getImageTextureType() == gl::TextureType::CubeMap)
+    {
+        gl::TextureType arrayType = imageVk->getImage()->getSamples() > 1
+                                        ? gl::TextureType::_2DMultisampleArray
+                                        : gl::TextureType::_2DArray;
+        ANGLE_TRY(mImage->initLayerImageView(contextVk, arrayType, aspect, gl::SwizzleState(),
+                                             &mCubeImageFetchView, imageVk->getImageLevel(), 1,
+                                             imageVk->getImageLayer(), 1));
+    }
+
+    mRenderTarget.init(mImage, &mImageView,
+                       mCubeImageFetchView.valid() ? &mCubeImageFetchView : nullptr,
+                       imageVk->getImageLevel(), imageVk->getImageLayer());
 
     return angle::Result::Continue;
 }
@@ -185,6 +197,7 @@ void RenderbufferVk::releaseImage(const gl::Context *context, RendererVk *render
     }
 
     renderer->releaseObject(renderer->getCurrentQueueSerial(), &mImageView);
+    renderer->releaseObject(renderer->getCurrentQueueSerial(), &mCubeImageFetchView);
 }
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/RenderbufferVk.h

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

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -163,9 +163,9 @@ OffscreenSurfaceVk::OffscreenSurfaceVk(const egl::SurfaceState &surfaceState,
                                        EGLint height)
     : SurfaceVk(surfaceState), mWidth(width), mHeight(height)
 {
-    mColorRenderTarget.init(&mColorAttachment.image, &mColorAttachment.imageView, 0, 0);
+    mColorRenderTarget.init(&mColorAttachment.image, &mColorAttachment.imageView, nullptr, 0, 0);
     mDepthStencilRenderTarget.init(&mDepthStencilAttachment.image,
-                                   &mDepthStencilAttachment.imageView, 0, 0);
+                                   &mDepthStencilAttachment.imageView, nullptr, 0, 0);
 }
 
 OffscreenSurfaceVk::~OffscreenSurfaceVk() {}
@@ -374,8 +374,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, 0, 0);
-    mDepthStencilRenderTarget.init(&mDepthStencilImage, &mDepthStencilImageView, 0, 0);
+    mColorRenderTarget.init(&mColorImageMS, &mColorImageViewMS, nullptr, 0, 0);
+    mDepthStencilRenderTarget.init(&mDepthStencilImage, &mDepthStencilImageView, nullptr, 0, 0);
 }
 
 WindowSurfaceVk::~WindowSurfaceVk()

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -426,9 +426,8 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,
         ASSERT(offsetImageIndex.getLayerCount() == 1);
 
         return copySubImageImplWithDraw(contextVk, offsetImageIndex, modifiedDestOffset, destFormat,
-                                        0, colorReadRT->getLayerIndex(), clippedSourceArea,
-                                        isViewportFlipY, false, false, false,
-                                        &colorReadRT->getImage(), colorReadRT->getReadImageView());
+                                        0, clippedSourceArea, isViewportFlipY, false, false, false,
+                                        &colorReadRT->getImage(), colorReadRT->getFetchImageView());
     }
 
     // Do a CPU readback that does the conversion, and then stage the change to the pixel buffer.
@@ -476,9 +475,9 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
     if (CanCopyWithDraw(renderer, sourceVkFormat, destVkFormat) && !forceCpuPath)
     {
         return copySubImageImplWithDraw(contextVk, offsetImageIndex, destOffset, destVkFormat,
-                                        sourceLevel, 0, sourceArea, false, unpackFlipY,
+                                        sourceLevel, sourceArea, false, unpackFlipY,
                                         unpackPremultiplyAlpha, unpackUnmultiplyAlpha,
-                                        &source->getImage(), &source->getReadImageView());
+                                        &source->getImage(), &source->getFetchImageView());
     }
 
     if (sourceLevel != 0)
@@ -626,7 +625,6 @@ angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
                                                   const gl::Offset &destOffset,
                                                   const vk::Format &destFormat,
                                                   size_t sourceLevel,
-                                                  size_t sourceLayer,
                                                   const gl::Rectangle &sourceArea,
                                                   bool isSrcFlipY,
                                                   bool unpackFlipY,
@@ -657,33 +655,6 @@ angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
     uint32_t baseLayer  = index.hasLayer() ? index.getLayerIndex() : 0;
     uint32_t layerCount = index.getLayerCount();
 
-    // If the source image is a cube map, the view is of VK_IMAGE_VIEW_TYPE_CUBE type.  However,
-    // GLSL's texelFetch cannot take a textureCube.  We need to create a 2D_ARRAY type view to be
-    // able to perform the copy.
-    //
-    // Note(syoussefi): Array textures are not yet supported in Vulkan.  Once they are, the if below
-    // should be changed to detect cube maps only.
-    vk::ImageView cubeAs2DArrayView;
-    if (srcImage->getLayerCount() % 6 == 0)
-    {
-        // TODO(syoussefi): If the cube map is LUMA, we need swizzle.  http://anglebug.com/2911
-        // This can't happen when copying from framebuffers, so only source of concern would be
-        // copy[Sub]Texture copying from a LUMA cube map.
-        ASSERT(!srcImage->getFormat().imageFormat().isLUMA());
-
-        gl::TextureType arrayTextureType =
-            Get2DTextureType(srcImage->getLayerCount(), srcImage->getSamples());
-        ANGLE_TRY(srcImage->initImageView(contextVk, arrayTextureType, VK_IMAGE_ASPECT_COLOR_BIT,
-                                          gl::SwizzleState(), &cubeAs2DArrayView, 0,
-                                          srcImage->getLevelCount()));
-        srcView = &cubeAs2DArrayView;
-    }
-    else
-    {
-        // Source layer is otherwise baked into the view
-        sourceLayer = 0;
-    }
-
     // If destination is valid, copy the source directly into it.
     if (mImage->valid())
     {
@@ -692,7 +663,7 @@ angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
 
         for (uint32_t layerIndex = 0; layerIndex < layerCount; ++layerIndex)
         {
-            params.srcLayer = sourceLayer + layerIndex;
+            params.srcLayer = layerIndex;
 
             vk::ImageView *destView;
             ANGLE_TRY(
@@ -720,7 +691,7 @@ angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
 
         for (uint32_t layerIndex = 0; layerIndex < layerCount; ++layerIndex)
         {
-            params.srcLayer = sourceLayer + layerIndex;
+            params.srcLayer = layerIndex;
 
             // Create a temporary view for this layer.
             vk::ImageView stagingView;
@@ -742,11 +713,6 @@ angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
             gl::Extents(sourceArea.width, sourceArea.height, 1));
     }
 
-    if (cubeAs2DArrayView.valid())
-    {
-        renderer->releaseObject(currentQueueSerial, &cubeAs2DArrayView);
-    }
-
     return angle::Result::Continue;
 }
 
@@ -928,8 +894,8 @@ void TextureVk::setImageHelper(RendererVk *renderer,
     mImage            = imageHelper;
     mImage->initStagingBuffer(renderer, format);
 
-    mRenderTarget.init(mImage, &mDrawBaseLevelImageView, getNativeImageLevel(0),
-                       getNativeImageLayer(0));
+    mRenderTarget.init(mImage, &mDrawBaseLevelImageView, &mFetchBaseLevelImageView,
+                       getNativeImageLevel(0), getNativeImageLayer(0));
 
     // Force re-creation of cube map render targets next time they are needed
     mCubeMapRenderTargets.clear();
@@ -1208,12 +1174,25 @@ angle::Result TextureVk::initCubeMapRenderTargets(ContextVk *contextVk)
     if (!mCubeMapRenderTargets.empty())
         return angle::Result::Continue;
 
+    mLayerFetchImageView.resize(gl::kCubeFaceCount);
     mCubeMapRenderTargets.resize(gl::kCubeFaceCount);
     for (size_t cubeMapFaceIndex = 0; cubeMapFaceIndex < gl::kCubeFaceCount; ++cubeMapFaceIndex)
     {
-        vk::ImageView *imageView;
-        ANGLE_TRY(getLayerLevelDrawImageView(contextVk, cubeMapFaceIndex, 0, &imageView));
-        mCubeMapRenderTargets[cubeMapFaceIndex].init(mImage, imageView, getNativeImageLevel(0),
+        vk::ImageView *drawView;
+        ANGLE_TRY(getLayerLevelDrawImageView(contextVk, cubeMapFaceIndex, 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(mImage->getFormat(), mState.getSwizzleState(), &mappedSwizzle);
+        gl::TextureType arrayType = Get2DTextureType(gl::kCubeFaceCount, mImage->getSamples());
+        ANGLE_TRY(mImage->initLayerImageView(contextVk, arrayType, mImage->getAspectFlags(),
+                                             mappedSwizzle, &mLayerFetchImageView[cubeMapFaceIndex],
+                                             getNativeImageLevel(0), 1,
+                                             getNativeImageLayer(cubeMapFaceIndex), 1));
+
+        mCubeMapRenderTargets[cubeMapFaceIndex].init(
+            mImage, drawView, &mLayerFetchImageView[cubeMapFaceIndex], getNativeImageLevel(0),
             getNativeImageLayer(cubeMapFaceIndex));
     }
     return angle::Result::Continue;
@@ -1302,8 +1281,7 @@ const vk::ImageView &TextureVk::getReadImageView() const
 {
     ASSERT(mImage->valid());
 
-    const GLenum minFilter = mState.getSamplerState().getMinFilter();
-    if (minFilter == GL_LINEAR || minFilter == GL_NEAREST)
+    if (!gl::IsMipmapFiltered(mState.getSamplerState()))
     {
         return mReadBaseLevelImageView;
     }
@@ -1311,6 +1289,23 @@ const vk::ImageView &TextureVk::getReadImageView() const
     return mReadMipmapImageView;
 }
 
+const vk::ImageView &TextureVk::getFetchImageView() const
+{
+    if (!mFetchBaseLevelImageView.valid())
+    {
+        return getReadImageView();
+    }
+
+    ASSERT(mImage->valid());
+
+    if (!gl::IsMipmapFiltered(mState.getSamplerState()))
+    {
+        return mFetchBaseLevelImageView;
+    }
+
+    return mFetchMipmapImageView;
+}
+
 angle::Result TextureVk::getLayerLevelDrawImageView(vk::Context *context,
                                                     size_t layer,
                                                     size_t level,
@@ -1428,6 +1423,17 @@ angle::Result TextureVk::initImageViews(ContextVk *contextVk,
     ANGLE_TRY(mImage->initLayerImageView(contextVk, mState.getType(), aspectFlags, mappedSwizzle,
                                          &mReadBaseLevelImageView, baseLevel, 1, baseLayer,
                                          layerCount));
+    if (mState.getType() == gl::TextureType::CubeMap)
+    {
+        gl::TextureType arrayType = Get2DTextureType(layerCount, mImage->getSamples());
+
+        ANGLE_TRY(mImage->initLayerImageView(contextVk, arrayType, aspectFlags, mappedSwizzle,
+                                             &mFetchMipmapImageView, baseLevel, levelCount,
+                                             baseLayer, layerCount));
+        ANGLE_TRY(mImage->initLayerImageView(contextVk, arrayType, aspectFlags, mappedSwizzle,
+                                             &mFetchBaseLevelImageView, baseLevel, 1, baseLayer,
+                                             layerCount));
+    }
     if (!format.imageFormat().isBlock)
     {
         ANGLE_TRY(mImage->initLayerImageView(contextVk, mState.getType(), aspectFlags,
@@ -1457,18 +1463,22 @@ void TextureVk::releaseImage(RendererVk *renderer)
     renderer->releaseObject(currentSerial, &mDrawBaseLevelImageView);
     renderer->releaseObject(currentSerial, &mReadBaseLevelImageView);
     renderer->releaseObject(currentSerial, &mReadMipmapImageView);
+    renderer->releaseObject(currentSerial, &mFetchBaseLevelImageView);
+    renderer->releaseObject(currentSerial, &mFetchMipmapImageView);
 
     for (auto &layerViews : mLayerLevelDrawImageViews)
     {
         for (vk::ImageView &imageView : layerViews)
         {
-            if (imageView.valid())
-            {
             renderer->releaseObject(currentSerial, &imageView);
         }
     }
-    }
     mLayerLevelDrawImageViews.clear();
+    for (vk::ImageView &imageView : mLayerFetchImageView)
+    {
+        renderer->releaseObject(currentSerial, &imageView);
+    }
+    mLayerFetchImageView.clear();
     mCubeMapRenderTargets.clear();
 }
 

src/libANGLE/renderer/vulkan/TextureVk.h

@@ -153,6 +153,8 @@ class TextureVk : public TextureImpl
     void releaseOwnershipOfImage(const gl::Context *context);
 
     const vk::ImageView &getReadImageView() const;
+    // A special view for cube maps as a 2D array, used with shaders that do texelFetch().
+    const vk::ImageView &getFetchImageView() const;
     angle::Result getLayerLevelDrawImageView(vk::Context *context,
                                              size_t layer,
                                              size_t level,
@@ -249,7 +251,6 @@ class TextureVk : public TextureImpl
                                            const gl::Offset &destOffset,
                                            const vk::Format &destFormat,
                                            size_t sourceLevel,
-                                           size_t sourceLayer,
                                            const gl::Rectangle &sourceArea,
                                            bool isSrcFlipY,
                                            bool unpackFlipY,
@@ -293,10 +294,13 @@ class TextureVk : public TextureImpl
     vk::ImageView mDrawBaseLevelImageView;
     vk::ImageView mReadBaseLevelImageView;
     vk::ImageView mReadMipmapImageView;
+    vk::ImageView mFetchBaseLevelImageView;
+    vk::ImageView mFetchMipmapImageView;
     std::vector<std::vector<vk::ImageView>> mLayerLevelDrawImageViews;
     vk::Sampler mSampler;
 
     RenderTargetVk mRenderTarget;
+    std::vector<vk::ImageView> mLayerFetchImageView;
     std::vector<RenderTargetVk> mCubeMapRenderTargets;
 };