Add support for getting vulkan descriptor sets without a GrVkUniformHandler.

src/gpu/vk/GrVkDescriptorSetManager.cpp

 /*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrVkDescriptorSetManager.h"
 
 #include "GrVkDescriptorPool.h"
 #include "GrVkDescriptorSet.h"
 #include "GrVkGpu.h"
 #include "GrVkUniformHandler.h"
 #include "glsl/GrGLSLSampler.h"
 
 GrVkDescriptorSetManager::GrVkDescriptorSetManager(GrVkGpu* gpu,
                                                    VkDescriptorType type,
                                                    const GrVkUniformHandler* uniformHandler)
     : fPoolManager(type, gpu, uniformHandler) {
     if (type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
         SkASSERT(uniformHandler);
         for (int i = 0; i < uniformHandler->numSamplers(); ++i) {
             fBindingVisibilities.push_back(uniformHandler->getSampler(i).visibility());

[jvanverth1, 2016/08/23 20:13:36]

Any possibility of storing the visibilities as a separate SkTArray in the
uniform handler or would that be too much of a nuisance? Then you'd only need
one constructor that takes an SkTArray.

         }
     } else {
         SkASSERT(type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
         // We set the visibility of the first binding to the vertex shader and the second to the
         // fragment shader.
         fBindingVisibilities.push_back(kVertex_GrShaderFlag);
         fBindingVisibilities.push_back(kFragment_GrShaderFlag);
     }
 }
 
+GrVkDescriptorSetManager::GrVkDescriptorSetManager(GrVkGpu* gpu,
+                                                   VkDescriptorType type,
+                                                   const uint32_t* visibilities,
+                                                   int visibilityCount)
+    : fPoolManager(type, gpu, visibilities, visibilityCount) {
+    if (type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
+        for (int i = 0; i < visibilityCount; ++i) {
+            fBindingVisibilities.push_back(visibilities[i]);
+        }
+    } else {
+        SkASSERT(type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
+        SkASSERT(!visibilities || (2 == visibilityCount &&
+                                   kVertex_GrShaderFlag == visibilities[0] &&
+                                   kFragment_GrShaderFlag == visibilities[1]));
+        // We set the visibility of the first binding to the vertex shader and the second to the
+        // fragment shader.
+        fBindingVisibilities.push_back(kVertex_GrShaderFlag);
+        fBindingVisibilities.push_back(kFragment_GrShaderFlag);
+    }
+}
+
 const GrVkDescriptorSet* GrVkDescriptorSetManager::getDescriptorSet(GrVkGpu* gpu,
                                                                     const Handle& handle) {
     const GrVkDescriptorSet* ds = nullptr;
     int count = fFreeSets.count();
     if (count > 0) {
         ds = fFreeSets[count - 1];
         fFreeSets.removeShuffle(count - 1);
     } else {
         VkDescriptorSet vkDS;
         fPoolManager.getNewDescriptorSet(gpu, &vkDS);
@@ skipping 40 matching lines @@
         }
         for (int i = 0; i < uniHandler->numSamplers(); ++i) {
             if (uniHandler->getSampler(i).visibility() != fBindingVisibilities[i]) {
                 return false;
             }
         }
     }
     return true;
 }
 
+bool GrVkDescriptorSetManager::isCompatible(VkDescriptorType type,
+                                            const uint32_t* visibilities,
+                                            int visibilityCount) const {
+    if (type != fPoolManager.fDescType) {
+        return false;
+    }
+
+    if (type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
+        SkASSERT(visibilities);
+        if (fBindingVisibilities.count() != visibilityCount) {
+            return false;
+        }
+        for (int i = 0; i < visibilityCount; ++i) {
+            if (visibilities[i] != fBindingVisibilities[i]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 VkShaderStageFlags visibility_to_vk_stage_flags(uint32_t visibility) {
     VkShaderStageFlags flags = 0;
 
     if (visibility & kVertex_GrShaderFlag) {
         flags |= VK_SHADER_STAGE_VERTEX_BIT;
     }
     if (visibility & kGeometry_GrShaderFlag) {
         flags |= VK_SHADER_STAGE_GEOMETRY_BIT;
     }
     if (visibility & kFragment_GrShaderFlag) {
         flags |= VK_SHADER_STAGE_FRAGMENT_BIT;
     }
     return flags;
 }
 
 GrVkDescriptorSetManager::DescriptorPoolManager::DescriptorPoolManager(
         VkDescriptorType type,
         GrVkGpu* gpu,
         const GrVkUniformHandler* uniformHandler)
     : fDescType(type)
     , fCurrentDescriptorCount(0)
     , fPool(nullptr) {
+    this->init(gpu, type, uniformHandler, nullptr, 0);
+}
+
+GrVkDescriptorSetManager::DescriptorPoolManager::DescriptorPoolManager(VkDescriptorType type,
+                                                                       GrVkGpu* gpu,
+                                                                       const uint32_t* visibilities,
+                                                                       int visibilityCount)
+    : fDescType(type)
+    , fCurrentDescriptorCount(0)
+    , fPool(nullptr) {
+    this->init(gpu, type, nullptr, visibilities, visibilityCount);
+}
+
+void GrVkDescriptorSetManager::DescriptorPoolManager::init(GrVkGpu* gpu,
+                                                           VkDescriptorType type,
+                                                           const GrVkUniformHandler* uniformHandler,
+                                                           const uint32_t* visibilities,
+                                                           int visibilityCount) {
     if (type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
-        SkASSERT(uniformHandler);
-        uint32_t numSamplers = (uint32_t)uniformHandler->numSamplers();
+        SkASSERT(SkToBool(uniformHandler) != SkToBool(visibilities));
+        uint32_t numSamplers;
+        if (uniformHandler) {
+            numSamplers = (uint32_t)uniformHandler->numSamplers();
+        } else {
+            numSamplers = (uint32_t)visibilityCount;
+        }
 
         SkAutoTDeleteArray<VkDescriptorSetLayoutBinding> dsSamplerBindings(
-                new VkDescriptorSetLayoutBinding[numSamplers]);
+            new VkDescriptorSetLayoutBinding[numSamplers]);
         for (uint32_t i = 0; i < numSamplers; ++i) {
-            const GrVkGLSLSampler& sampler =
+            uint32_t visibility;
+            if (uniformHandler) {
+                const GrVkGLSLSampler& sampler =
                     static_cast<const GrVkGLSLSampler&>(uniformHandler->getSampler(i));
-            SkASSERT(sampler.binding() == i);
-            dsSamplerBindings[i].binding = sampler.binding();
+                SkASSERT(sampler.binding() == i);
+                visibility = sampler.visibility();
+            } else {
+                visibility = visibilities[i];
+            }
+            dsSamplerBindings[i].binding = i;
             dsSamplerBindings[i].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
             dsSamplerBindings[i].descriptorCount = 1;
-            dsSamplerBindings[i].stageFlags = visibility_to_vk_stage_flags(sampler.visibility());
+            dsSamplerBindings[i].stageFlags = visibility_to_vk_stage_flags(visibility);
             dsSamplerBindings[i].pImmutableSamplers = nullptr;
         }
 
         VkDescriptorSetLayoutCreateInfo dsSamplerLayoutCreateInfo;
         memset(&dsSamplerLayoutCreateInfo, 0, sizeof(VkDescriptorSetLayoutCreateInfo));
         dsSamplerLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
         dsSamplerLayoutCreateInfo.pNext = nullptr;
         dsSamplerLayoutCreateInfo.flags = 0;
         dsSamplerLayoutCreateInfo.bindingCount = numSamplers;
         // Setting to nullptr fixes an error in the param checker validation layer. Even though
@@ skipping 97 matching lines @@
     }
 }
 
 void GrVkDescriptorSetManager::DescriptorPoolManager::abandonGPUResources() {
     fDescLayout = VK_NULL_HANDLE;
     if (fPool) {
         fPool->unrefAndAbandon();
         fPool = nullptr;
     }
 }