Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2016 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #ifndef GrVkResourceProvider_DEFINED |
| 9 | #define GrVkResourceProvider_DEFINED |
| 10 | |
egdaniel | d62e28b | 2016-06-07 08:43:30 -0700 | [diff] [blame] | 11 | #include "GrResourceHandle.h" |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 12 | #include "GrVkDescriptorPool.h" |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 13 | #include "GrVkDescriptorSetManager.h" |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 14 | #include "GrVkPipelineState.h" |
egdaniel | 2feb093 | 2016-06-08 06:48:09 -0700 | [diff] [blame] | 15 | #include "GrVkRenderPass.h" |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 16 | #include "GrVkResource.h" |
| 17 | #include "GrVkUtil.h" |
Ethan Nicholas | 87f340e | 2017-01-03 14:32:01 -0500 | [diff] [blame] | 18 | #include "SkLRUCache.h" |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 19 | #include "SkTArray.h" |
egdaniel | 8b6394c | 2016-03-04 07:35:10 -0800 | [diff] [blame] | 20 | #include "SkTDynamicHash.h" |
egdaniel | af13277 | 2016-03-28 12:39:29 -0700 | [diff] [blame] | 21 | #include "SkTInternalLList.h" |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 22 | |
jvanverth | e50f3e7 | 2016-03-28 07:03:06 -0700 | [diff] [blame] | 23 | #include "vk/GrVkDefines.h" |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 24 | |
| 25 | class GrPipeline; |
| 26 | class GrPrimitiveProcessor; |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 27 | class GrSamplerState; |
egdaniel | bc9b296 | 2016-09-27 08:00:53 -0700 | [diff] [blame] | 28 | class GrVkCopyPipeline; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 29 | class GrVkGpu; |
| 30 | class GrVkPipeline; |
jvanverth | 7ec9241 | 2016-07-06 09:24:57 -0700 | [diff] [blame] | 31 | class GrVkPrimaryCommandBuffer; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 32 | class GrVkRenderTarget; |
egdaniel | 8b6394c | 2016-03-04 07:35:10 -0800 | [diff] [blame] | 33 | class GrVkSampler; |
jvanverth | 7ec9241 | 2016-07-06 09:24:57 -0700 | [diff] [blame] | 34 | class GrVkSecondaryCommandBuffer; |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 35 | class GrVkUniformHandler; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 36 | |
| 37 | class GrVkResourceProvider { |
| 38 | public: |
| 39 | GrVkResourceProvider(GrVkGpu* gpu); |
| 40 | ~GrVkResourceProvider(); |
| 41 | |
jvanverth | 03509ea | 2016-03-02 13:19:47 -0800 | [diff] [blame] | 42 | // Set up any initial vk objects |
| 43 | void init(); |
| 44 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 45 | GrVkPipeline* createPipeline(const GrPipeline& pipeline, |
csmartdalton | c633abb | 2016-11-01 08:55:55 -0700 | [diff] [blame] | 46 | const GrStencilSettings& stencil, |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 47 | const GrPrimitiveProcessor& primProc, |
| 48 | VkPipelineShaderStageCreateInfo* shaderStageInfo, |
| 49 | int shaderStageCount, |
| 50 | GrPrimitiveType primitiveType, |
| 51 | const GrVkRenderPass& renderPass, |
| 52 | VkPipelineLayout layout); |
| 53 | |
egdaniel | bc9b296 | 2016-09-27 08:00:53 -0700 | [diff] [blame] | 54 | GrVkCopyPipeline* findOrCreateCopyPipeline(const GrVkRenderTarget* dst, |
| 55 | VkPipelineShaderStageCreateInfo*, |
| 56 | VkPipelineLayout); |
| 57 | |
egdaniel | d62e28b | 2016-06-07 08:43:30 -0700 | [diff] [blame] | 58 | GR_DEFINE_RESOURCE_HANDLE_CLASS(CompatibleRPHandle); |
| 59 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 60 | // Finds or creates a simple render pass that matches the target, increments the refcount, |
egdaniel | d62e28b | 2016-06-07 08:43:30 -0700 | [diff] [blame] | 61 | // and returns. The caller can optionally pass in a pointer to a CompatibleRPHandle. If this is |
| 62 | // non null it will be set to a handle that can be used in the furutre to quickly return a |
| 63 | // compatible GrVkRenderPasses without the need inspecting a GrVkRenderTarget. |
| 64 | const GrVkRenderPass* findCompatibleRenderPass(const GrVkRenderTarget& target, |
| 65 | CompatibleRPHandle* compatibleHandle = nullptr); |
| 66 | // The CompatibleRPHandle must be a valid handle previously set by a call to |
| 67 | // findCompatibleRenderPass(GrVkRenderTarget&, CompatibleRPHandle*). |
| 68 | const GrVkRenderPass* findCompatibleRenderPass(const CompatibleRPHandle& compatibleHandle); |
| 69 | |
egdaniel | 2feb093 | 2016-06-08 06:48:09 -0700 | [diff] [blame] | 70 | // Finds or creates a render pass that matches the target and LoadStoreOps, increments the |
| 71 | // refcount, and returns. The caller can optionally pass in a pointer to a CompatibleRPHandle. |
| 72 | // If this is non null it will be set to a handle that can be used in the furutre to quickly |
| 73 | // return a GrVkRenderPasses without the need inspecting a GrVkRenderTarget. |
egdaniel | d62e28b | 2016-06-07 08:43:30 -0700 | [diff] [blame] | 74 | const GrVkRenderPass* findRenderPass(const GrVkRenderTarget& target, |
egdaniel | 2feb093 | 2016-06-08 06:48:09 -0700 | [diff] [blame] | 75 | const GrVkRenderPass::LoadStoreOps& colorOps, |
egdaniel | 2feb093 | 2016-06-08 06:48:09 -0700 | [diff] [blame] | 76 | const GrVkRenderPass::LoadStoreOps& stencilOps, |
egdaniel | d62e28b | 2016-06-07 08:43:30 -0700 | [diff] [blame] | 77 | CompatibleRPHandle* compatibleHandle = nullptr); |
| 78 | |
egdaniel | 2feb093 | 2016-06-08 06:48:09 -0700 | [diff] [blame] | 79 | // The CompatibleRPHandle must be a valid handle previously set by a call to findRenderPass or |
| 80 | // findCompatibleRenderPass. |
egdaniel | d62e28b | 2016-06-07 08:43:30 -0700 | [diff] [blame] | 81 | const GrVkRenderPass* findRenderPass(const CompatibleRPHandle& compatibleHandle, |
egdaniel | 2feb093 | 2016-06-08 06:48:09 -0700 | [diff] [blame] | 82 | const GrVkRenderPass::LoadStoreOps& colorOps, |
egdaniel | 2feb093 | 2016-06-08 06:48:09 -0700 | [diff] [blame] | 83 | const GrVkRenderPass::LoadStoreOps& stencilOps); |
| 84 | |
jvanverth | 7ec9241 | 2016-07-06 09:24:57 -0700 | [diff] [blame] | 85 | GrVkPrimaryCommandBuffer* findOrCreatePrimaryCommandBuffer(); |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 86 | void checkCommandBuffers(); |
| 87 | |
jvanverth | 7ec9241 | 2016-07-06 09:24:57 -0700 | [diff] [blame] | 88 | GrVkSecondaryCommandBuffer* findOrCreateSecondaryCommandBuffer(); |
| 89 | void recycleSecondaryCommandBuffer(GrVkSecondaryCommandBuffer* cb); |
| 90 | |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 91 | // Finds or creates a compatible GrVkDescriptorPool for the requested type and count. |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 92 | // The refcount is incremented and a pointer returned. |
| 93 | // TODO: Currently this will just create a descriptor pool without holding onto a ref itself |
| 94 | // so we currently do not reuse them. Rquires knowing if another draw is currently using |
| 95 | // the GrVkDescriptorPool, the ability to reset pools, and the ability to purge pools out |
| 96 | // of our cache of GrVkDescriptorPools. |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 97 | GrVkDescriptorPool* findOrCreateCompatibleDescriptorPool(VkDescriptorType type, uint32_t count); |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 98 | |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 99 | // Finds or creates a compatible GrVkSampler based on the GrSamplerState. |
egdaniel | 8b6394c | 2016-03-04 07:35:10 -0800 | [diff] [blame] | 100 | // The refcount is incremented and a pointer returned. |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 101 | GrVkSampler* findOrCreateCompatibleSampler(const GrSamplerState&, uint32_t maxMipLevel); |
egdaniel | 8b6394c | 2016-03-04 07:35:10 -0800 | [diff] [blame] | 102 | |
Greg Daniel | 09eeefb | 2017-10-16 15:15:02 -0400 | [diff] [blame] | 103 | GrVkPipelineState* findOrCreateCompatiblePipelineState(const GrPipeline&, |
| 104 | const GrPrimitiveProcessor&, |
| 105 | GrPrimitiveType, |
| 106 | const GrVkRenderPass& renderPass); |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 107 | |
Greg Daniel | a754378 | 2017-05-02 14:01:43 -0400 | [diff] [blame] | 108 | void getSamplerDescriptorSetHandle(VkDescriptorType type, |
| 109 | const GrVkUniformHandler&, |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 110 | GrVkDescriptorSetManager::Handle* handle); |
Greg Daniel | a754378 | 2017-05-02 14:01:43 -0400 | [diff] [blame] | 111 | void getSamplerDescriptorSetHandle(VkDescriptorType type, |
| 112 | const SkTArray<uint32_t>& visibilities, |
egdaniel | 4d866df | 2016-08-25 13:52:00 -0700 | [diff] [blame] | 113 | GrVkDescriptorSetManager::Handle* handle); |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 114 | |
| 115 | // Returns the compatible VkDescriptorSetLayout to use for uniform buffers. The caller does not |
| 116 | // own the VkDescriptorSetLayout and thus should not delete it. This function should be used |
| 117 | // when the caller needs the layout to create a VkPipelineLayout. |
| 118 | VkDescriptorSetLayout getUniformDSLayout() const; |
| 119 | |
| 120 | // Returns the compatible VkDescriptorSetLayout to use for a specific sampler handle. The caller |
| 121 | // does not own the VkDescriptorSetLayout and thus should not delete it. This function should be |
| 122 | // used when the caller needs the layout to create a VkPipelineLayout. |
| 123 | VkDescriptorSetLayout getSamplerDSLayout(const GrVkDescriptorSetManager::Handle&) const; |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 124 | |
| 125 | // Returns a GrVkDescriptorSet that can be used for uniform buffers. The GrVkDescriptorSet |
| 126 | // is already reffed for the caller. |
| 127 | const GrVkDescriptorSet* getUniformDescriptorSet(); |
| 128 | |
| 129 | // Returns a GrVkDescriptorSet that can be used for sampler descriptors that are compatible with |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 130 | // the GrVkDescriptorSetManager::Handle passed in. The GrVkDescriptorSet is already reffed for |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 131 | // the caller. |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 132 | const GrVkDescriptorSet* getSamplerDescriptorSet(const GrVkDescriptorSetManager::Handle&); |
egdaniel | 778555c | 2016-05-02 06:50:36 -0700 | [diff] [blame] | 133 | |
egdaniel | 778555c | 2016-05-02 06:50:36 -0700 | [diff] [blame] | 134 | |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 135 | // Signals that the descriptor set passed it, which is compatible with the passed in handle, |
| 136 | // can be reused by the next allocation request. |
| 137 | void recycleDescriptorSet(const GrVkDescriptorSet* descSet, |
| 138 | const GrVkDescriptorSetManager::Handle&); |
| 139 | |
jvanverth | 4c6e47a | 2016-07-22 10:34:52 -0700 | [diff] [blame] | 140 | // Creates or finds free uniform buffer resources of size GrVkUniformBuffer::kStandardSize. |
| 141 | // Anything larger will need to be created and released by the client. |
| 142 | const GrVkResource* findOrCreateStandardUniformBufferResource(); |
| 143 | |
| 144 | // Signals that the resource passed to it (which should be a uniform buffer resource) |
| 145 | // can be reused by the next uniform buffer resource request. |
| 146 | void recycleStandardUniformBufferResource(const GrVkResource*); |
| 147 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 148 | // Destroy any cached resources. To be called before destroying the VkDevice. |
| 149 | // The assumption is that all queues are idle and all command buffers are finished. |
| 150 | // For resource tracing to work properly, this should be called after unrefing all other |
| 151 | // resource usages. |
Jim Van Verth | 09557d7 | 2016-11-07 11:10:21 -0500 | [diff] [blame] | 152 | // If deviceLost is true, then resources will not be checked to see if they've finished |
| 153 | // before deleting (see section 4.2.4 of the Vulkan spec). |
| 154 | void destroyResources(bool deviceLost); |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 155 | |
| 156 | // Abandon any cached resources. To be used when the context/VkDevice is lost. |
| 157 | // For resource tracing to work properly, this should be called after unrefing all other |
| 158 | // resource usages. |
| 159 | void abandonResources(); |
| 160 | |
| 161 | private: |
djsollen | efe46d2 | 2016-04-29 06:41:35 -0700 | [diff] [blame] | 162 | #ifdef SK_DEBUG |
egdaniel | af13277 | 2016-03-28 12:39:29 -0700 | [diff] [blame] | 163 | #define GR_PIPELINE_STATE_CACHE_STATS |
| 164 | #endif |
| 165 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 166 | class PipelineStateCache : public ::SkNoncopyable { |
| 167 | public: |
| 168 | PipelineStateCache(GrVkGpu* gpu); |
| 169 | ~PipelineStateCache(); |
| 170 | |
| 171 | void abandon(); |
| 172 | void release(); |
Greg Daniel | 09eeefb | 2017-10-16 15:15:02 -0400 | [diff] [blame] | 173 | GrVkPipelineState* refPipelineState(const GrPipeline&, |
| 174 | const GrPrimitiveProcessor&, |
| 175 | GrPrimitiveType, |
| 176 | const GrVkRenderPass& renderPass); |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 177 | |
| 178 | private: |
| 179 | enum { |
| 180 | // We may actually have kMaxEntries+1 PipelineStates in context because we create a new |
| 181 | // PipelineState before evicting from the cache. |
| 182 | kMaxEntries = 128, |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 183 | }; |
| 184 | |
| 185 | struct Entry; |
| 186 | |
Ethan Nicholas | 87f340e | 2017-01-03 14:32:01 -0500 | [diff] [blame] | 187 | struct DescHash { |
| 188 | uint32_t operator()(const GrProgramDesc& desc) const { |
| 189 | return SkOpts::hash_fn(desc.asKey(), desc.keyLength(), 0); |
| 190 | } |
| 191 | }; |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 192 | |
Ethan Nicholas | 87f340e | 2017-01-03 14:32:01 -0500 | [diff] [blame] | 193 | SkLRUCache<const GrVkPipelineState::Desc, std::unique_ptr<Entry>, DescHash> fMap; |
egdaniel | af13277 | 2016-03-28 12:39:29 -0700 | [diff] [blame] | 194 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 195 | GrVkGpu* fGpu; |
egdaniel | af13277 | 2016-03-28 12:39:29 -0700 | [diff] [blame] | 196 | |
| 197 | #ifdef GR_PIPELINE_STATE_CACHE_STATS |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 198 | int fTotalRequests; |
| 199 | int fCacheMisses; |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 200 | #endif |
| 201 | }; |
| 202 | |
egdaniel | d62e28b | 2016-06-07 08:43:30 -0700 | [diff] [blame] | 203 | class CompatibleRenderPassSet { |
| 204 | public: |
| 205 | // This will always construct the basic load store render pass (all attachments load and |
| 206 | // store their data) so that there is at least one compatible VkRenderPass that can be used |
| 207 | // with this set. |
| 208 | CompatibleRenderPassSet(const GrVkGpu* gpu, const GrVkRenderTarget& target); |
| 209 | |
| 210 | bool isCompatible(const GrVkRenderTarget& target) const; |
| 211 | |
| 212 | GrVkRenderPass* getCompatibleRenderPass() const { |
| 213 | // The first GrVkRenderpass should always exist since we create the basic load store |
| 214 | // render pass on create |
| 215 | SkASSERT(fRenderPasses[0]); |
| 216 | return fRenderPasses[0]; |
| 217 | } |
| 218 | |
egdaniel | 2feb093 | 2016-06-08 06:48:09 -0700 | [diff] [blame] | 219 | GrVkRenderPass* getRenderPass(const GrVkGpu* gpu, |
| 220 | const GrVkRenderPass::LoadStoreOps& colorOps, |
egdaniel | 2feb093 | 2016-06-08 06:48:09 -0700 | [diff] [blame] | 221 | const GrVkRenderPass::LoadStoreOps& stencilOps); |
| 222 | |
egdaniel | d62e28b | 2016-06-07 08:43:30 -0700 | [diff] [blame] | 223 | void releaseResources(const GrVkGpu* gpu); |
| 224 | void abandonResources(); |
| 225 | |
| 226 | private: |
| 227 | SkSTArray<4, GrVkRenderPass*> fRenderPasses; |
| 228 | int fLastReturnedIndex; |
| 229 | }; |
| 230 | |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 231 | GrVkGpu* fGpu; |
| 232 | |
jvanverth | 03509ea | 2016-03-02 13:19:47 -0800 | [diff] [blame] | 233 | // Central cache for creating pipelines |
| 234 | VkPipelineCache fPipelineCache; |
| 235 | |
egdaniel | bc9b296 | 2016-09-27 08:00:53 -0700 | [diff] [blame] | 236 | // Cache of previously created copy pipelines |
| 237 | SkTArray<GrVkCopyPipeline*> fCopyPipelines; |
| 238 | |
egdaniel | d62e28b | 2016-06-07 08:43:30 -0700 | [diff] [blame] | 239 | SkSTArray<4, CompatibleRenderPassSet> fRenderPassArray; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 240 | |
jvanverth | 7ec9241 | 2016-07-06 09:24:57 -0700 | [diff] [blame] | 241 | // Array of PrimaryCommandBuffers that are currently in flight |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 242 | SkSTArray<4, GrVkPrimaryCommandBuffer*, true> fActiveCommandBuffers; |
jvanverth | 7ec9241 | 2016-07-06 09:24:57 -0700 | [diff] [blame] | 243 | // Array of available primary command buffers that are not in flight |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 244 | SkSTArray<4, GrVkPrimaryCommandBuffer*, true> fAvailableCommandBuffers; |
jvanverth | 7ec9241 | 2016-07-06 09:24:57 -0700 | [diff] [blame] | 245 | |
| 246 | // Array of available secondary command buffers |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 247 | SkSTArray<16, GrVkSecondaryCommandBuffer*, true> fAvailableSecondaryCommandBuffers; |
egdaniel | 8b6394c | 2016-03-04 07:35:10 -0800 | [diff] [blame] | 248 | |
jvanverth | 4c6e47a | 2016-07-22 10:34:52 -0700 | [diff] [blame] | 249 | // Array of available uniform buffer resources |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 250 | SkSTArray<16, const GrVkResource*, true> fAvailableUniformBufferResources; |
jvanverth | 4c6e47a | 2016-07-22 10:34:52 -0700 | [diff] [blame] | 251 | |
egdaniel | 8b6394c | 2016-03-04 07:35:10 -0800 | [diff] [blame] | 252 | // Stores GrVkSampler objects that we've already created so we can reuse them across multiple |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 253 | // GrVkPipelineStates |
jvanverth | 6234006 | 2016-04-26 08:01:44 -0700 | [diff] [blame] | 254 | SkTDynamicHash<GrVkSampler, uint16_t> fSamplers; |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 255 | |
| 256 | // Cache of GrVkPipelineStates |
| 257 | PipelineStateCache* fPipelineStateCache; |
egdaniel | 778555c | 2016-05-02 06:50:36 -0700 | [diff] [blame] | 258 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 259 | SkSTArray<4, std::unique_ptr<GrVkDescriptorSetManager>> fDescriptorSetManagers; |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 260 | |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 261 | GrVkDescriptorSetManager::Handle fUniformDSHandle; |
Greg Daniel | 164a9f0 | 2016-02-22 09:56:40 -0500 | [diff] [blame] | 262 | }; |
| 263 | |
| 264 | #endif |