Add support for sampling stencil texture

src/libANGLE/Texture.h

@@ -134,6 +134,7 @@ class TextureState final : private angle::NonCopyable
     const SamplerState &getSamplerState() const { return mSamplerState; }
     GLenum getUsage() const { return mUsage; }
     GLenum getDepthStencilTextureMode() const { return mDepthStencilTextureMode; }
+    bool isStencilMode() const { return mDepthStencilTextureMode == GL_STENCIL_INDEX; }
 
     // Returns the desc of the base level. Only valid for cube-complete/mip-complete textures.
     const ImageDesc &getBaseLevelDesc() const;

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -71,8 +71,27 @@ uint32_t GetRenderTargetLayerCount(vk::ImageHelper *image)
     // Depth > 1 means this is a 3D texture and depth is our layer count
     return image->getExtents().depth > 1 ? image->getExtents().depth : image->getLayerCount();
 }
+
+bool HasBothDepthAndStencilAspects(VkImageAspectFlags aspectFlags)
+{
+    constexpr VkImageAspectFlags kDepthStencilAspects =
+        VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_DEPTH_BIT;
+    return (aspectFlags & kDepthStencilAspects) == kDepthStencilAspects;
+}
 }  // anonymous namespace
 
+TextureVk::TextureVkViews::TextureVkViews() {}
+TextureVk::TextureVkViews::~TextureVkViews() {}
+
+void TextureVk::TextureVkViews::release(ContextVk *contextVk, Serial currentSerial)
+{
+    contextVk->releaseObject(currentSerial, &mDrawBaseLevelImageView);
+    contextVk->releaseObject(currentSerial, &mReadBaseLevelImageView);
+    contextVk->releaseObject(currentSerial, &mReadMipmapImageView);
+    contextVk->releaseObject(currentSerial, &mFetchBaseLevelImageView);
+    contextVk->releaseObject(currentSerial, &mFetchMipmapImageView);
+}
+
 angle::Result TextureVk::generateMipmapLevelsWithCPU(ContextVk *contextVk,
                                                      const angle::Format &sourceFormat,
                                                      GLuint layer,
@@ -907,8 +926,9 @@ void TextureVk::setImageHelper(ContextVk *contextVk,
     mImage->initStagingBuffer(contextVk->getRenderer(), format, vk::kStagingBufferFlags,
                               mStagingBufferInitialSize);
 
-    mRenderTarget.init(mImage, &mDrawBaseLevelImageView, &mFetchBaseLevelImageView,
-                       getNativeImageLevel(0), getNativeImageLayer(0));
+    mRenderTarget.init(mImage, &mDefaultViews.mDrawBaseLevelImageView,
+                       &mDefaultViews.mFetchBaseLevelImageView, getNativeImageLevel(0),
+                       getNativeImageLayer(0));
 
     // Force re-creation of layered render targets next time they are needed
     mCubeMapRenderTargets.clear();
@@ -1290,6 +1310,16 @@ angle::Result TextureVk::syncState(const gl::Context *context,
 
     float maxAnisotropy   = samplerState.getMaxAnisotropy();
     bool anisotropyEnable = extensions.textureFilterAnisotropic && maxAnisotropy > 1.0f;
+    bool compareEnable    = samplerState.getCompareMode() == GL_COMPARE_REF_TO_TEXTURE;
+    VkCompareOp compareOp = gl_vk::GetCompareOp(samplerState.getCompareFunc());
+    // When sampling from stencil, deqp tests expect texture compare to have no effect
+    // dEQP - GLES31.functional.stencil_texturing.misc.compare_mode_effect
+    // states: NOTE: Texture compare mode has no effect when reading stencil values.
+    if (mState.isStencilMode())
+    {
+        compareEnable = VK_FALSE;
+        compareOp     = VK_COMPARE_OP_ALWAYS;
+    }
 
     // Create a simple sampler. Force basic parameter settings.
     VkSamplerCreateInfo samplerInfo     = {};
@@ -1304,8 +1334,8 @@ angle::Result TextureVk::syncState(const gl::Context *context,
     samplerInfo.mipLodBias              = 0.0f;
     samplerInfo.anisotropyEnable        = anisotropyEnable;
     samplerInfo.maxAnisotropy           = maxAnisotropy;
-    samplerInfo.compareEnable       = samplerState.getCompareMode() == GL_COMPARE_REF_TO_TEXTURE;
-    samplerInfo.compareOp           = gl_vk::GetCompareOp(samplerState.getCompareFunc());
+    samplerInfo.compareEnable           = compareEnable;
+    samplerInfo.compareOp               = compareOp;
     samplerInfo.minLod                  = samplerState.getMinLod();
     samplerInfo.maxLod                  = samplerState.getMaxLod();
     samplerInfo.borderColor             = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
@@ -1352,33 +1382,46 @@ void TextureVk::releaseOwnershipOfImage(const gl::Context *context)
     releaseAndDeleteImage(contextVk);
 }
 
+const TextureVk::TextureVkViews *TextureVk::getTextureViews() const
+{
+    VkImageAspectFlags aspectFlags = mImage->getAspectFlags();
+    if (HasBothDepthAndStencilAspects(aspectFlags) && mState.isStencilMode())
+    {
+        return &mStencilViews;
+    }
+    return &mDefaultViews;
+}
+
 const vk::ImageView &TextureVk::getReadImageView() const
 {
     ASSERT(mImage->valid());
+    const TextureVkViews *activeView = getTextureViews();
 
     if (!gl::IsMipmapFiltered(mState.getSamplerState()))
     {
-        return mReadBaseLevelImageView;
+        return activeView->mReadBaseLevelImageView;
     }
 
-    return mReadMipmapImageView;
+    return activeView->mReadMipmapImageView;
 }
 
 const vk::ImageView &TextureVk::getFetchImageView() const
 {
-    if (!mFetchBaseLevelImageView.valid())
+
+    if (!mDefaultViews.mFetchBaseLevelImageView.valid())
     {
         return getReadImageView();
     }
 
     ASSERT(mImage->valid());
+    const TextureVkViews *activeView = getTextureViews();
 
     if (!gl::IsMipmapFiltered(mState.getSamplerState()))
     {
-        return mFetchBaseLevelImageView;
+        return activeView->mFetchBaseLevelImageView;
     }
 
-    return mFetchMipmapImageView;
+    return activeView->mFetchMipmapImageView;
 }
 
 angle::Result TextureVk::getLayerLevelDrawImageView(vk::Context *context,
@@ -1481,33 +1524,24 @@ angle::Result TextureVk::initImage(ContextVk *contextVk,
     return angle::Result::Continue;
 }
 
-angle::Result TextureVk::initImageViews(ContextVk *contextVk,
+angle::Result TextureVk::initImageViewImpl(ContextVk *contextVk,
                                            const vk::Format &format,
                                            uint32_t levelCount,
-                                        uint32_t layerCount)
+                                           uint32_t layerCount,
+                                           TextureVkViews *view,
+                                           VkImageAspectFlags aspectFlags,
+                                           gl::SwizzleState mappedSwizzle)
 {
-    ASSERT(mImage != nullptr);
-
-    gl::SwizzleState mappedSwizzle;
-    MapSwizzleState(contextVk, format, mState.getSwizzleState(), &mappedSwizzle);
-
     // TODO: Support non-zero base level for ES 3.0 by passing it to getNativeImageLevel.
     // http://anglebug.com/3148
     uint32_t baseLevel = getNativeImageLevel(0);
     uint32_t baseLayer = getNativeImageLayer(0);
 
-    VkImageAspectFlags aspectFlags = vk::GetFormatAspectFlags(format.angleFormat());
-    // If we are reading a depth buffer, select only the depth component/aspect
-    if (aspectFlags & VK_IMAGE_ASPECT_DEPTH_BIT)
-    {
-        aspectFlags = VK_IMAGE_ASPECT_DEPTH_BIT;
-    }
-
     ANGLE_TRY(mImage->initLayerImageView(contextVk, mState.getType(), aspectFlags, mappedSwizzle,
-                                         &mReadMipmapImageView, baseLevel, levelCount, baseLayer,
-                                         layerCount));
+                                         &view->mReadMipmapImageView, baseLevel, levelCount,
+                                         baseLayer, layerCount));
     ANGLE_TRY(mImage->initLayerImageView(contextVk, mState.getType(), aspectFlags, mappedSwizzle,
-                                         &mReadBaseLevelImageView, baseLevel, 1, baseLayer,
+                                         &view->mReadBaseLevelImageView, baseLevel, 1, baseLayer,
                                          layerCount));
     if (mState.getType() == gl::TextureType::CubeMap ||
         mState.getType() == gl::TextureType::_2DArray ||
@@ -1516,22 +1550,45 @@ angle::Result TextureVk::initImageViews(ContextVk *contextVk,
         gl::TextureType arrayType = vk::Get2DTextureType(layerCount, mImage->getSamples());
 
         ANGLE_TRY(mImage->initLayerImageView(contextVk, arrayType, aspectFlags, mappedSwizzle,
-                                             &mFetchMipmapImageView, baseLevel, levelCount,
+                                             &view->mFetchMipmapImageView, baseLevel, levelCount,
                                              baseLayer, layerCount));
         ANGLE_TRY(mImage->initLayerImageView(contextVk, arrayType, aspectFlags, mappedSwizzle,
-                                             &mFetchBaseLevelImageView, baseLevel, 1, baseLayer,
-                                             layerCount));
+                                             &view->mFetchBaseLevelImageView, baseLevel, 1,
+                                             baseLayer, layerCount));
     }
     if (!format.imageFormat().isBlock)
     {
         ANGLE_TRY(mImage->initLayerImageView(contextVk, mState.getType(), aspectFlags,
-                                             gl::SwizzleState(), &mDrawBaseLevelImageView,
+                                             gl::SwizzleState(), &view->mDrawBaseLevelImageView,
                                              baseLevel, 1, baseLayer, layerCount));
     }
 
     return angle::Result::Continue;
 }
 
+angle::Result TextureVk::initImageViews(ContextVk *contextVk,
+                                        const vk::Format &format,
+                                        uint32_t levelCount,
+                                        uint32_t layerCount)
+{
+    ASSERT(mImage != nullptr);
+
+    gl::SwizzleState mappedSwizzle;
+    MapSwizzleState(contextVk, format, mState.getSwizzleState(), &mappedSwizzle);
+
+    VkImageAspectFlags aspectFlags = vk::GetFormatAspectFlags(format.angleFormat());
+    if (HasBothDepthAndStencilAspects(aspectFlags))
+    {
+        ANGLE_TRY(initImageViewImpl(contextVk, format, levelCount, layerCount, &mStencilViews,
+                                    VK_IMAGE_ASPECT_STENCIL_BIT, mappedSwizzle));
+        aspectFlags = VK_IMAGE_ASPECT_DEPTH_BIT;
+    }
+    ANGLE_TRY(initImageViewImpl(contextVk, format, levelCount, layerCount, &mDefaultViews,
+                                aspectFlags, mappedSwizzle));
+
+    return angle::Result::Continue;
+}
+
 void TextureVk::releaseImage(ContextVk *contextVk)
 {
     if (mImage)
@@ -1558,11 +1615,9 @@ void TextureVk::releaseImageViews(ContextVk *contextVk)
 {
     Serial currentSerial = contextVk->getCurrentQueueSerial();
 
-    contextVk->releaseObject(currentSerial, &mDrawBaseLevelImageView);
-    contextVk->releaseObject(currentSerial, &mReadBaseLevelImageView);
-    contextVk->releaseObject(currentSerial, &mReadMipmapImageView);
-    contextVk->releaseObject(currentSerial, &mFetchBaseLevelImageView);
-    contextVk->releaseObject(currentSerial, &mFetchMipmapImageView);
+    mDefaultViews.release(contextVk, currentSerial);
+
+    mStencilViews.release(contextVk, currentSerial);
 
     for (auto &layerViews : mLayerLevelDrawImageViews)
     {

src/libANGLE/renderer/vulkan/TextureVk.h

@@ -173,6 +173,19 @@ class TextureVk : public TextureImpl
     }
 
   private:
+    struct TextureVkViews final : angle::NonCopyable
+    {
+        TextureVkViews();
+        ~TextureVkViews();
+
+        void release(ContextVk *contextVk, Serial currentSerial);
+        vk::ImageView mDrawBaseLevelImageView;
+        vk::ImageView mReadBaseLevelImageView;
+        vk::ImageView mReadMipmapImageView;
+        vk::ImageView mFetchBaseLevelImageView;
+        vk::ImageView mFetchMipmapImageView;
+    };
+
     // Transform an image index from the frontend into one that can be used on the backing
     // ImageHelper, taking into account mipmap or cube face offsets
     gl::ImageIndex getNativeImageIndex(const gl::ImageIndex &inputImageIndex) const;
@@ -283,6 +296,13 @@ class TextureVk : public TextureImpl
                                  uint32_t levelCount,
                                  uint32_t layerCount);
     angle::Result init3DRenderTargets(ContextVk *contextVk);
+    angle::Result initImageViewImpl(ContextVk *contextVk,
+                                    const vk::Format &format,
+                                    uint32_t levelCount,
+                                    uint32_t layerCount,
+                                    TextureVkViews *views,
+                                    VkImageAspectFlags aspectFlags,
+                                    gl::SwizzleState mappedSwizzle);
     angle::Result initCubeMapRenderTargets(ContextVk *contextVk);
 
     angle::Result ensureImageInitializedImpl(ContextVk *contextVk,
@@ -292,6 +312,8 @@ class TextureVk : public TextureImpl
 
     void onStagingBufferChange() { onStateChange(angle::SubjectMessage::SubjectChanged); }
 
+    const TextureVkViews *getTextureViews() const;
+
     bool mOwnsImage;
 
     gl::TextureType mImageNativeType;
@@ -306,11 +328,8 @@ class TextureVk : public TextureImpl
 
     vk::ImageHelper *mImage;
 
-    vk::ImageView mDrawBaseLevelImageView;
-    vk::ImageView mReadBaseLevelImageView;
-    vk::ImageView mReadMipmapImageView;
-    vk::ImageView mFetchBaseLevelImageView;
-    vk::ImageView mFetchMipmapImageView;
+    TextureVkViews mDefaultViews;
+    TextureVkViews mStencilViews;
     std::vector<std::vector<vk::ImageView>> mLayerLevelDrawImageViews;
     vk::Sampler mSampler;
 

src/tests/deqp_support/deqp_gles31_test_expectations.txt

@@ -695,8 +695,10 @@
 // Transform feedback:
 3205 VULKAN : dEQP-GLES31.functional.debug.*transform_feedback = SKIP
 
-// Stencil textures (some missing support for 3D and 2D array textures):
-3585 VULKAN : dEQP-GLES31.functional.stencil_texturing.* = SKIP
+// Stencil textures (some missing support for base level):
+3683 VULKAN PIXEL2 : dEQP-GLES31.functional.stencil_texturing.format.* = FAIL
+3683 VULKAN PIXEL2 : dEQP-GLES31.functional.stencil_texturing.misc.compare_mode_effect = FAIL
+3148 VULKAN : dEQP-GLES31.functional.stencil_texturing.misc.base_level = SKIP
 
 // Multisampled textures:
 3565 VULKAN : dEQP-GLES31.functional.texture.multisample.* = SKIP