Add DescriptorPool and set manager to GrVkProgram

src/gpu/vk/GrVkProgram.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrVkProgram_DEFINED
 #define GrVkProgram_DEFINED
@@ skipping 37 matching lines @@
     void abandonGPUResources();
 
 private:
     typedef GrVkProgramDataManager::UniformInfoArray UniformInfoArray;
     typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
 
     GrVkProgram(GrVkGpu* gpu,
                 GrVkPipeline* pipeline,
                 VkPipelineLayout layout,
                 VkDescriptorSetLayout dsLayout[2],
-                GrVkDescriptorPool* descriptorPool,
-                VkDescriptorSet descriptorSets[2],
                 const BuiltinUniformHandles& builtinUniformHandles,
                 const UniformInfoArray& uniforms,
                 uint32_t vertexUniformSize,
                 uint32_t fragmentUniformSize,
                 uint32_t numSamplers,
                 GrGLSLPrimitiveProcessor* geometryProcessor,
                 GrGLSLXferProcessor* xferProcessor,
                 const GrGLSLFragProcs& fragmentProcessors);
 
+    // Each pool will manage one type of descriptor. Thus each descriptor set we use will all be of
+    // one VkDescriptorType.
+    struct DescriptorPoolManager {
+        DescriptorPoolManager(VkDescriptorSetLayout layout, VkDescriptorType type,
+                              uint8_t descCount, GrVkGpu* gpu)
+            : fDescLayout(layout)
+            , fDescType(type)
+            , fDescCount(descCount)
+            , fMaxDescriptorSets(4)
+            , fCurrentDescriptorSet(0)
+            , fPool(nullptr) {
+            if (fDescCount * fMaxDescriptorSets > 1 << 8) {

[jvanverth1, 2016/03/07 19:04:11]

Use a constant rather than 1 << 8? And why 256?

[egdaniel, 2016/03/07 20:02:25]

The descriptorpool type count struct I made previously (with array of the
descriptor types), we decided to make the counts be uint8_t to reduce the size.
Thus I need to make sure we never try to make more than 256.

I will add a constant though.

+                fMaxDescriptorSets = 1;
+            }
+            this->getNewPool(gpu);
+        }
+
+        ~DescriptorPoolManager() {
+            SkASSERT(!fDescLayout);
+            SkASSERT(!fPool);
+        }
+
+        void getNewDescriptorSet(GrVkGpu* gpu, VkDescriptorSet* ds);
+
+        void freeGPUResources(const GrVkGpu* gpu);
+        void abandonGPUResources();
+
+        VkDescriptorSetLayout  fDescLayout;
+        VkDescriptorType       fDescType;
+        uint8_t                fDescCount;
+        uint8_t                fMaxDescriptorSets;
+        uint8_t                fCurrentDescriptorSet;
+        GrVkDescriptorPool*    fPool;
+
+    private:
+        void getNewPool(GrVkGpu* gpu);
+    };
+
     void writeUniformBuffers(const GrVkGpu* gpu);
 
     void writeSamplers(GrVkGpu* gpu, const SkTArray<const GrTextureAccess*>& textureBindings);
 
 
     /**
     * We use the RT's size and origin to adjust from Skia device space to OpenGL normalized device
     * space and to make device space positions have the correct origin for processors that require
     * them.
     */
@@ skipping 24 matching lines @@
             } else {
                 destVec[2] = 2.f / fRenderTargetSize.fHeight;
                 destVec[3] = -1.f;
             }
         }
     };
 
     // Helper for setData() that sets the view matrix and loads the render target height uniform
     void setRenderTargetState(const GrPipeline&);
 
-//    GrVkGpu* fGpu;
-
     // GrVkResources
-    GrVkDescriptorPool* fDescriptorPool;
     GrVkPipeline*       fPipeline;
 
     // Used for binding DescriptorSets to the command buffer but does not need to survive during
     // command buffer execution. Thus this is not need to be a GrVkResource.
     VkPipelineLayout fPipelineLayout;
 
-    // The first set (index 0) will be used for samplers and the second set (index 1) will be
-    // used for uniform buffers.
-    // The DSLayouts only are needed for allocating the descriptor sets and must survive until after
-    // descriptor sets have been updated. Thus the lifetime of the layouts will just be the life of
-    //the GrVkProgram.
-    VkDescriptorSetLayout fDSLayout[2];
     // The DescriptorSets need to survive until the gpu has finished all draws that use them.
     // However, they will only be freed by the descriptor pool. Thus by simply keeping the
     // descriptor pool alive through the draw, the descritor sets will also stay alive. Thus we do
-    // not need a GrVkResource versions of VkDescriptorSet.
+    // not need a GrVkResource versions of VkDescriptorSet. We hold on to these in the program since
+    // we update the descriptor sets and bind them at separate times;
     VkDescriptorSet       fDescriptorSets[2];
 
+    // Meta data so we know which descriptor sets we are using and need to bind.
+    int                   fStartDS;
+    int                   fDSCount;
+
     SkAutoTDelete<GrVkUniformBuffer>    fVertexUniformBuffer;
     SkAutoTDelete<GrVkUniformBuffer>    fFragmentUniformBuffer;
 
     // GrVkResources used for sampling textures
     SkTDArray<GrVkSampler*>                fSamplers;
     SkTDArray<const GrVkImageView*>        fTextureViews;
     SkTDArray<const GrVkImage::Resource*>  fTextures;
 
     // Tracks the current render target uniforms stored in the vertex buffer.
     RenderTargetState fRenderTargetState;
     BuiltinUniformHandles fBuiltinUniformHandles;
 
     // Processors in the program
     SkAutoTDelete<GrGLSLPrimitiveProcessor> fGeometryProcessor;
     SkAutoTDelete<GrGLSLXferProcessor> fXferProcessor;
     GrGLSLFragProcs fFragmentProcessors;
 
     GrVkProgramDataManager fProgramDataManager;
 
+    DescriptorPoolManager  fSamplerPoolManager;
+    DescriptorPoolManager  fUniformPoolManager;
+
 #ifdef SK_DEBUG
     int fNumSamplers;
 #endif
 
     friend class GrVkProgramBuilder;
 };
 
 #endif