jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [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 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 8 | #include "GrVkPipelineState.h" |
Robert Phillips | 9bee2e5 | 2017-05-29 12:37:20 -0400 | [diff] [blame] | 9 | #include "GrContext.h" |
Robert Phillips | 6be756b | 2018-01-16 15:07:54 -0500 | [diff] [blame] | 10 | #include "GrContextPriv.h" |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 11 | #include "GrPipeline.h" |
Brian Salomon | 1471df9 | 2018-06-08 10:49:00 -0400 | [diff] [blame] | 12 | #include "GrRenderTarget.h" |
jvanverth | 6234006 | 2016-04-26 08:01:44 -0700 | [diff] [blame] | 13 | #include "GrTexturePriv.h" |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 14 | #include "GrVkBufferView.h" |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 15 | #include "GrVkCommandBuffer.h" |
| 16 | #include "GrVkDescriptorPool.h" |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 17 | #include "GrVkDescriptorSet.h" |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 18 | #include "GrVkGpu.h" |
| 19 | #include "GrVkImageView.h" |
| 20 | #include "GrVkMemory.h" |
| 21 | #include "GrVkPipeline.h" |
Greg Daniel | 7d918fd | 2018-06-19 15:22:01 -0400 | [diff] [blame^] | 22 | #include "GrVkPipelineLayout.h" |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 23 | #include "GrVkSampler.h" |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 24 | #include "GrVkTexelBuffer.h" |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 25 | #include "GrVkTexture.h" |
| 26 | #include "GrVkUniformBuffer.h" |
Brian Salomon | 1471df9 | 2018-06-08 10:49:00 -0400 | [diff] [blame] | 27 | #include "SkMipMap.h" |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 28 | #include "glsl/GrGLSLFragmentProcessor.h" |
| 29 | #include "glsl/GrGLSLGeometryProcessor.h" |
| 30 | #include "glsl/GrGLSLXferProcessor.h" |
| 31 | |
Brian Salomon | 1471df9 | 2018-06-08 10:49:00 -0400 | [diff] [blame] | 32 | GrVkPipelineState::GrVkPipelineState( |
| 33 | GrVkGpu* gpu, |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 34 | GrVkPipeline* pipeline, |
| 35 | VkPipelineLayout layout, |
| 36 | const GrVkDescriptorSetManager::Handle& samplerDSHandle, |
| 37 | const GrVkDescriptorSetManager::Handle& texelBufferDSHandle, |
Brian Salomon | 1471df9 | 2018-06-08 10:49:00 -0400 | [diff] [blame] | 38 | const GrGLSLBuiltinUniformHandles& builtinUniformHandles, |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 39 | const UniformInfoArray& uniforms, |
| 40 | uint32_t geometryUniformSize, |
| 41 | uint32_t fragmentUniformSize, |
| 42 | uint32_t numSamplers, |
| 43 | uint32_t numTexelBuffers, |
| 44 | std::unique_ptr<GrGLSLPrimitiveProcessor> geometryProcessor, |
| 45 | std::unique_ptr<GrGLSLXferProcessor> xferProcessor, |
| 46 | std::unique_ptr<std::unique_ptr<GrGLSLFragmentProcessor>[]> fragmentProcessors, |
| 47 | int fragmentProcessorCnt) |
| 48 | : fPipeline(pipeline) |
Greg Daniel | 7d918fd | 2018-06-19 15:22:01 -0400 | [diff] [blame^] | 49 | , fPipelineLayout(new GrVkPipelineLayout(layout)) |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 50 | , fUniformDescriptorSet(nullptr) |
| 51 | , fSamplerDescriptorSet(nullptr) |
| 52 | , fTexelBufferDescriptorSet(nullptr) |
| 53 | , fSamplerDSHandle(samplerDSHandle) |
| 54 | , fTexelBufferDSHandle(texelBufferDSHandle) |
| 55 | , fBuiltinUniformHandles(builtinUniformHandles) |
| 56 | , fGeometryProcessor(std::move(geometryProcessor)) |
| 57 | , fXferProcessor(std::move(xferProcessor)) |
| 58 | , fFragmentProcessors(std::move(fragmentProcessors)) |
| 59 | , fFragmentProcessorCnt(fragmentProcessorCnt) |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 60 | , fDataManager(uniforms, geometryUniformSize, fragmentUniformSize) { |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 61 | fSamplers.setReserve(numSamplers); |
| 62 | fTextureViews.setReserve(numSamplers); |
| 63 | fTextures.setReserve(numSamplers); |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 64 | fBufferViews.setReserve(numTexelBuffers); |
| 65 | fTexelBuffers.setReserve(numTexelBuffers); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 66 | |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 67 | fDescriptorSets[0] = VK_NULL_HANDLE; |
| 68 | fDescriptorSets[1] = VK_NULL_HANDLE; |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 69 | fDescriptorSets[2] = VK_NULL_HANDLE; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 70 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 71 | fGeometryUniformBuffer.reset(GrVkUniformBuffer::Create(gpu, geometryUniformSize)); |
jvanverth | 4c6e47a | 2016-07-22 10:34:52 -0700 | [diff] [blame] | 72 | fFragmentUniformBuffer.reset(GrVkUniformBuffer::Create(gpu, fragmentUniformSize)); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 73 | |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 74 | fNumSamplers = numSamplers; |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 75 | fNumTexelBuffers = numTexelBuffers; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 76 | } |
| 77 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 78 | GrVkPipelineState::~GrVkPipelineState() { |
Ethan Nicholas | 87f340e | 2017-01-03 14:32:01 -0500 | [diff] [blame] | 79 | // Must have freed all GPU resources before this is destroyed |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 80 | SkASSERT(!fPipeline); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 81 | SkASSERT(!fPipelineLayout); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 82 | SkASSERT(!fSamplers.count()); |
| 83 | SkASSERT(!fTextureViews.count()); |
| 84 | SkASSERT(!fTextures.count()); |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 85 | SkASSERT(!fBufferViews.count()); |
| 86 | SkASSERT(!fTexelBuffers.count()); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 87 | } |
| 88 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 89 | void GrVkPipelineState::freeTempResources(const GrVkGpu* gpu) { |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 90 | for (int i = 0; i < fSamplers.count(); ++i) { |
| 91 | fSamplers[i]->unref(gpu); |
| 92 | } |
| 93 | fSamplers.rewind(); |
| 94 | |
| 95 | for (int i = 0; i < fTextureViews.count(); ++i) { |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 96 | fTextureViews[i]->unref(gpu); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 97 | } |
| 98 | fTextureViews.rewind(); |
| 99 | |
| 100 | for (int i = 0; i < fTextures.count(); ++i) { |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 101 | fTextures[i]->unref(gpu); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 102 | } |
| 103 | fTextures.rewind(); |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 104 | |
| 105 | for (int i = 0; i < fBufferViews.count(); ++i) { |
| 106 | fBufferViews[i]->unref(gpu); |
| 107 | } |
| 108 | fBufferViews.rewind(); |
| 109 | |
| 110 | for (int i = 0; i < fTexelBuffers.count(); ++i) { |
| 111 | fTexelBuffers[i]->unref(gpu); |
| 112 | } |
| 113 | fTexelBuffers.rewind(); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 114 | } |
| 115 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 116 | void GrVkPipelineState::freeGPUResources(const GrVkGpu* gpu) { |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 117 | if (fPipeline) { |
| 118 | fPipeline->unref(gpu); |
| 119 | fPipeline = nullptr; |
| 120 | } |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 121 | |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 122 | if (fPipelineLayout) { |
Greg Daniel | 7d918fd | 2018-06-19 15:22:01 -0400 | [diff] [blame^] | 123 | fPipelineLayout->unref(gpu); |
| 124 | fPipelineLayout = nullptr; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 125 | } |
| 126 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 127 | if (fGeometryUniformBuffer) { |
| 128 | fGeometryUniformBuffer->release(gpu); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 129 | } |
| 130 | |
| 131 | if (fFragmentUniformBuffer) { |
| 132 | fFragmentUniformBuffer->release(gpu); |
| 133 | } |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 134 | |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 135 | if (fUniformDescriptorSet) { |
| 136 | fUniformDescriptorSet->recycle(const_cast<GrVkGpu*>(gpu)); |
| 137 | fUniformDescriptorSet = nullptr; |
egdaniel | 778555c | 2016-05-02 06:50:36 -0700 | [diff] [blame] | 138 | } |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 139 | |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 140 | if (fSamplerDescriptorSet) { |
| 141 | fSamplerDescriptorSet->recycle(const_cast<GrVkGpu*>(gpu)); |
| 142 | fSamplerDescriptorSet = nullptr; |
| 143 | } |
| 144 | |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 145 | if (fTexelBufferDescriptorSet) { |
| 146 | fTexelBufferDescriptorSet->recycle(const_cast<GrVkGpu*>(gpu)); |
| 147 | fTexelBufferDescriptorSet = nullptr; |
| 148 | } |
| 149 | |
| 150 | |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 151 | this->freeTempResources(gpu); |
| 152 | } |
| 153 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 154 | void GrVkPipelineState::abandonGPUResources() { |
Greg Daniel | 7d918fd | 2018-06-19 15:22:01 -0400 | [diff] [blame^] | 155 | if (fPipeline) { |
| 156 | fPipeline->unrefAndAbandon(); |
| 157 | fPipeline = nullptr; |
| 158 | } |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 159 | |
Greg Daniel | 7d918fd | 2018-06-19 15:22:01 -0400 | [diff] [blame^] | 160 | if (fPipelineLayout) { |
| 161 | fPipelineLayout->unrefAndAbandon(); |
| 162 | fPipelineLayout = nullptr; |
| 163 | } |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 164 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 165 | fGeometryUniformBuffer->abandon(); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 166 | fFragmentUniformBuffer->abandon(); |
| 167 | |
| 168 | for (int i = 0; i < fSamplers.count(); ++i) { |
| 169 | fSamplers[i]->unrefAndAbandon(); |
| 170 | } |
| 171 | fSamplers.rewind(); |
| 172 | |
| 173 | for (int i = 0; i < fTextureViews.count(); ++i) { |
| 174 | fTextureViews[i]->unrefAndAbandon(); |
| 175 | } |
| 176 | fTextureViews.rewind(); |
| 177 | |
| 178 | for (int i = 0; i < fTextures.count(); ++i) { |
| 179 | fTextures[i]->unrefAndAbandon(); |
| 180 | } |
| 181 | fTextures.rewind(); |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 182 | |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 183 | for (int i = 0; i < fBufferViews.count(); ++i) { |
| 184 | fBufferViews[i]->unrefAndAbandon(); |
| 185 | } |
| 186 | fBufferViews.rewind(); |
| 187 | |
| 188 | for (int i = 0; i < fTexelBuffers.count(); ++i) { |
| 189 | fTexelBuffers[i]->unrefAndAbandon(); |
| 190 | } |
| 191 | |
| 192 | fTexelBuffers.rewind(); |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 193 | if (fUniformDescriptorSet) { |
| 194 | fUniformDescriptorSet->unrefAndAbandon(); |
| 195 | fUniformDescriptorSet = nullptr; |
egdaniel | 778555c | 2016-05-02 06:50:36 -0700 | [diff] [blame] | 196 | } |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 197 | |
| 198 | if (fSamplerDescriptorSet) { |
| 199 | fSamplerDescriptorSet->unrefAndAbandon(); |
| 200 | fSamplerDescriptorSet = nullptr; |
| 201 | } |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 202 | |
| 203 | if (fTexelBufferDescriptorSet) { |
| 204 | fTexelBufferDescriptorSet->unrefAndAbandon(); |
| 205 | fTexelBufferDescriptorSet = nullptr; |
| 206 | } |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 207 | } |
| 208 | |
Brian Salomon | ab015ef | 2017-04-04 10:15:51 -0400 | [diff] [blame] | 209 | static void append_texture_bindings( |
| 210 | const GrResourceIOProcessor& processor, |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 211 | SkTArray<const GrResourceIOProcessor::TextureSampler*>* textureBindings, |
| 212 | SkTArray<const GrResourceIOProcessor::BufferAccess*>* bufferAccesses) { |
Brian Salomon | 0bbecb2 | 2016-11-17 11:38:22 -0500 | [diff] [blame] | 213 | if (int numTextureSamplers = processor.numTextureSamplers()) { |
Brian Salomon | ab015ef | 2017-04-04 10:15:51 -0400 | [diff] [blame] | 214 | const GrResourceIOProcessor::TextureSampler** bindings = |
Brian Salomon | 0bbecb2 | 2016-11-17 11:38:22 -0500 | [diff] [blame] | 215 | textureBindings->push_back_n(numTextureSamplers); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 216 | int i = 0; |
| 217 | do { |
Brian Salomon | 0bbecb2 | 2016-11-17 11:38:22 -0500 | [diff] [blame] | 218 | bindings[i] = &processor.textureSampler(i); |
| 219 | } while (++i < numTextureSamplers); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 220 | } |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 221 | if (int numTexelBuffers = processor.numBuffers()) { |
| 222 | const GrResourceIOProcessor::BufferAccess** accesses = |
| 223 | bufferAccesses->push_back_n(numTexelBuffers); |
| 224 | int i = 0; |
| 225 | do { |
| 226 | accesses[i] = &processor.bufferAccess(i); |
| 227 | } while (++i < numTexelBuffers); |
| 228 | } |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 229 | } |
| 230 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 231 | void GrVkPipelineState::setData(GrVkGpu* gpu, |
| 232 | const GrPrimitiveProcessor& primProc, |
| 233 | const GrPipeline& pipeline) { |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 234 | // This is here to protect against someone calling setData multiple times in a row without |
| 235 | // freeing the tempData between calls. |
| 236 | this->freeTempResources(gpu); |
| 237 | |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 238 | this->setRenderTargetState(pipeline.proxy()); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 239 | |
Brian Salomon | ab015ef | 2017-04-04 10:15:51 -0400 | [diff] [blame] | 240 | SkSTArray<8, const GrResourceIOProcessor::TextureSampler*> textureBindings; |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 241 | SkSTArray<8, const GrResourceIOProcessor::BufferAccess*> bufferAccesses; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 242 | |
bsalomon | a624bf3 | 2016-09-20 09:12:47 -0700 | [diff] [blame] | 243 | fGeometryProcessor->setData(fDataManager, primProc, |
| 244 | GrFragmentProcessor::CoordTransformIter(pipeline)); |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 245 | append_texture_bindings(primProc, &textureBindings, &bufferAccesses); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 246 | |
bsalomon | b58a2b4 | 2016-09-26 06:55:02 -0700 | [diff] [blame] | 247 | GrFragmentProcessor::Iter iter(pipeline); |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 248 | GrGLSLFragmentProcessor::Iter glslIter(fFragmentProcessors.get(), fFragmentProcessorCnt); |
bsalomon | b58a2b4 | 2016-09-26 06:55:02 -0700 | [diff] [blame] | 249 | const GrFragmentProcessor* fp = iter.next(); |
| 250 | GrGLSLFragmentProcessor* glslFP = glslIter.next(); |
| 251 | while (fp && glslFP) { |
| 252 | glslFP->setData(fDataManager, *fp); |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 253 | append_texture_bindings(*fp, &textureBindings, &bufferAccesses); |
mtklein | 85552e4 | 2016-09-26 08:39:43 -0700 | [diff] [blame] | 254 | fp = iter.next(); |
| 255 | glslFP = glslIter.next(); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 256 | } |
bsalomon | b58a2b4 | 2016-09-26 06:55:02 -0700 | [diff] [blame] | 257 | SkASSERT(!fp && !glslFP); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 258 | |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 259 | { |
| 260 | SkIPoint offset; |
| 261 | GrTexture* dstTexture = pipeline.peekDstTexture(&offset); |
| 262 | |
| 263 | fXferProcessor->setData(fDataManager, pipeline.getXferProcessor(), dstTexture, offset); |
| 264 | } |
| 265 | |
Robert Phillips | 6be756b | 2018-01-16 15:07:54 -0500 | [diff] [blame] | 266 | GrResourceProvider* resourceProvider = gpu->getContext()->contextPriv().resourceProvider(); |
| 267 | |
Brian Salomon | ab015ef | 2017-04-04 10:15:51 -0400 | [diff] [blame] | 268 | GrResourceIOProcessor::TextureSampler dstTextureSampler; |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 269 | if (GrTextureProxy* dstTextureProxy = pipeline.dstTextureProxy()) { |
Robert Phillips | fbcef6e | 2017-06-15 12:07:18 -0400 | [diff] [blame] | 270 | dstTextureSampler.reset(sk_ref_sp(dstTextureProxy)); |
Robert Phillips | 6be756b | 2018-01-16 15:07:54 -0500 | [diff] [blame] | 271 | SkAssertResult(dstTextureSampler.instantiate(resourceProvider)); |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 272 | textureBindings.push_back(&dstTextureSampler); |
| 273 | } |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 274 | |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 275 | // Get new descriptor sets |
| 276 | if (fNumSamplers) { |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 277 | if (fSamplerDescriptorSet) { |
| 278 | fSamplerDescriptorSet->recycle(gpu); |
| 279 | } |
| 280 | fSamplerDescriptorSet = gpu->resourceProvider().getSamplerDescriptorSet(fSamplerDSHandle); |
| 281 | int samplerDSIdx = GrVkUniformHandler::kSamplerDescSet; |
| 282 | fDescriptorSets[samplerDSIdx] = fSamplerDescriptorSet->descriptorSet(); |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 283 | this->writeSamplers(gpu, textureBindings); |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 284 | } |
egdaniel | b4aa362 | 2016-04-06 13:47:08 -0700 | [diff] [blame] | 285 | |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 286 | if (fNumTexelBuffers) { |
| 287 | if (fTexelBufferDescriptorSet) { |
| 288 | fTexelBufferDescriptorSet->recycle(gpu); |
| 289 | } |
| 290 | fTexelBufferDescriptorSet = |
| 291 | gpu->resourceProvider().getSamplerDescriptorSet(fTexelBufferDSHandle); |
| 292 | int texelBufferDSIdx = GrVkUniformHandler::kTexelBufferDescSet; |
| 293 | fDescriptorSets[texelBufferDSIdx] = fTexelBufferDescriptorSet->descriptorSet(); |
| 294 | this->writeTexelBuffers(gpu, bufferAccesses); |
| 295 | } |
| 296 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 297 | if (fGeometryUniformBuffer || fFragmentUniformBuffer) { |
Ben Wagner | 145dbcd | 2016-11-03 14:40:50 -0400 | [diff] [blame] | 298 | if (fDataManager.uploadUniformBuffers(gpu, |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 299 | fGeometryUniformBuffer.get(), |
Ben Wagner | 145dbcd | 2016-11-03 14:40:50 -0400 | [diff] [blame] | 300 | fFragmentUniformBuffer.get()) |
| 301 | || !fUniformDescriptorSet) |
| 302 | { |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 303 | if (fUniformDescriptorSet) { |
| 304 | fUniformDescriptorSet->recycle(gpu); |
egdaniel | 778555c | 2016-05-02 06:50:36 -0700 | [diff] [blame] | 305 | } |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 306 | fUniformDescriptorSet = gpu->resourceProvider().getUniformDescriptorSet(); |
| 307 | int uniformDSIdx = GrVkUniformHandler::kUniformBufferDescSet; |
| 308 | fDescriptorSets[uniformDSIdx] = fUniformDescriptorSet->descriptorSet(); |
egdaniel | 7cbffda | 2016-04-08 13:27:53 -0700 | [diff] [blame] | 309 | this->writeUniformBuffers(gpu); |
| 310 | } |
egdaniel | b4aa362 | 2016-04-06 13:47:08 -0700 | [diff] [blame] | 311 | } |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 312 | } |
| 313 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 314 | void set_uniform_descriptor_writes(VkWriteDescriptorSet* descriptorWrite, |
| 315 | VkDescriptorBufferInfo* bufferInfo, |
| 316 | const GrVkUniformBuffer* buffer, |
| 317 | VkDescriptorSet descriptorSet, |
| 318 | uint32_t binding) { |
| 319 | |
| 320 | memset(bufferInfo, 0, sizeof(VkDescriptorBufferInfo)); |
| 321 | bufferInfo->buffer = buffer->buffer(); |
| 322 | bufferInfo->offset = buffer->offset(); |
| 323 | bufferInfo->range = buffer->size(); |
| 324 | |
| 325 | memset(descriptorWrite, 0, sizeof(VkWriteDescriptorSet)); |
| 326 | descriptorWrite->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; |
| 327 | descriptorWrite->pNext = nullptr; |
Greg Daniel | 783c436 | 2017-05-04 17:29:09 -0400 | [diff] [blame] | 328 | descriptorWrite->dstSet = descriptorSet; |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 329 | descriptorWrite->dstBinding = binding; |
| 330 | descriptorWrite->dstArrayElement = 0; |
| 331 | descriptorWrite->descriptorCount = 1; |
| 332 | descriptorWrite->descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; |
| 333 | descriptorWrite->pImageInfo = nullptr; |
| 334 | descriptorWrite->pBufferInfo = bufferInfo; |
| 335 | descriptorWrite->pTexelBufferView = nullptr; |
| 336 | } |
| 337 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 338 | void GrVkPipelineState::writeUniformBuffers(const GrVkGpu* gpu) { |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 339 | VkWriteDescriptorSet descriptorWrites[3]; |
| 340 | VkDescriptorBufferInfo bufferInfos[3]; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 341 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 342 | uint32_t writeCount = 0; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 343 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 344 | // Geometry Uniform Buffer |
| 345 | if (fGeometryUniformBuffer.get()) { |
| 346 | set_uniform_descriptor_writes(&descriptorWrites[writeCount], |
| 347 | &bufferInfos[writeCount], |
| 348 | fGeometryUniformBuffer.get(), |
| 349 | fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet], |
| 350 | GrVkUniformHandler::kGeometryBinding); |
| 351 | ++writeCount; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 352 | } |
| 353 | |
| 354 | // Fragment Uniform Buffer |
| 355 | if (fFragmentUniformBuffer.get()) { |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 356 | set_uniform_descriptor_writes(&descriptorWrites[writeCount], |
| 357 | &bufferInfos[writeCount], |
| 358 | fFragmentUniformBuffer.get(), |
| 359 | fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet], |
| 360 | GrVkUniformHandler::kFragBinding); |
| 361 | ++writeCount; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 362 | } |
| 363 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 364 | if (writeCount) { |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 365 | GR_VK_CALL(gpu->vkInterface(), UpdateDescriptorSets(gpu->device(), |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 366 | writeCount, |
| 367 | descriptorWrites, |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 368 | 0, nullptr)); |
| 369 | } |
| 370 | } |
| 371 | |
Brian Salomon | 0bbecb2 | 2016-11-17 11:38:22 -0500 | [diff] [blame] | 372 | void GrVkPipelineState::writeSamplers( |
| 373 | GrVkGpu* gpu, |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 374 | const SkTArray<const GrResourceIOProcessor::TextureSampler*>& textureBindings) { |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 375 | SkASSERT(fNumSamplers == textureBindings.count()); |
| 376 | |
| 377 | for (int i = 0; i < textureBindings.count(); ++i) { |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 378 | GrSamplerState state = textureBindings[i]->samplerState(); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 379 | |
Robert Phillips | 9bee2e5 | 2017-05-29 12:37:20 -0400 | [diff] [blame] | 380 | GrVkTexture* texture = static_cast<GrVkTexture*>(textureBindings[i]->peekTexture()); |
jvanverth | 6234006 | 2016-04-26 08:01:44 -0700 | [diff] [blame] | 381 | |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 382 | fSamplers.push(gpu->resourceProvider().findOrCreateCompatibleSampler( |
| 383 | state, texture->texturePriv().maxMipMapLevel())); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 384 | |
egdaniel | b2df0c2 | 2016-05-13 11:30:37 -0700 | [diff] [blame] | 385 | const GrVkResource* textureResource = texture->resource(); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 386 | textureResource->ref(); |
| 387 | fTextures.push(textureResource); |
| 388 | |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 389 | const GrVkImageView* textureView = texture->textureView(); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 390 | textureView->ref(); |
| 391 | fTextureViews.push(textureView); |
| 392 | |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 393 | VkDescriptorImageInfo imageInfo; |
| 394 | memset(&imageInfo, 0, sizeof(VkDescriptorImageInfo)); |
| 395 | imageInfo.sampler = fSamplers[i]->sampler(); |
brianosman | f05ab1b | 2016-05-12 11:01:10 -0700 | [diff] [blame] | 396 | imageInfo.imageView = textureView->imageView(); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 397 | imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; |
| 398 | |
| 399 | VkWriteDescriptorSet writeInfo; |
| 400 | memset(&writeInfo, 0, sizeof(VkWriteDescriptorSet)); |
| 401 | writeInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; |
| 402 | writeInfo.pNext = nullptr; |
| 403 | writeInfo.dstSet = fDescriptorSets[GrVkUniformHandler::kSamplerDescSet]; |
| 404 | writeInfo.dstBinding = i; |
| 405 | writeInfo.dstArrayElement = 0; |
| 406 | writeInfo.descriptorCount = 1; |
| 407 | writeInfo.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; |
| 408 | writeInfo.pImageInfo = &imageInfo; |
| 409 | writeInfo.pBufferInfo = nullptr; |
| 410 | writeInfo.pTexelBufferView = nullptr; |
| 411 | |
| 412 | GR_VK_CALL(gpu->vkInterface(), UpdateDescriptorSets(gpu->device(), |
| 413 | 1, |
| 414 | &writeInfo, |
| 415 | 0, |
| 416 | nullptr)); |
| 417 | } |
| 418 | } |
| 419 | |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 420 | void GrVkPipelineState::writeTexelBuffers( |
| 421 | GrVkGpu* gpu, |
| 422 | const SkTArray<const GrResourceIOProcessor::BufferAccess*>& bufferAccesses) { |
| 423 | SkASSERT(fNumTexelBuffers == bufferAccesses.count()); |
| 424 | |
| 425 | for (int i = 0; i < bufferAccesses.count(); ++i) { |
| 426 | GrPixelConfig config = bufferAccesses[i]->texelConfig(); |
| 427 | VkFormat format; |
| 428 | SkAssertResult(GrPixelConfigToVkFormat(config, &format)); |
| 429 | |
| 430 | GrVkTexelBuffer* buffer = static_cast<GrVkTexelBuffer*>(bufferAccesses[i]->buffer()); |
| 431 | |
| 432 | const GrVkBufferView* bufferView = GrVkBufferView::Create(gpu, buffer->buffer(), |
| 433 | format, buffer->offset(), |
| 434 | buffer->size()); |
| 435 | fBufferViews.push(bufferView); |
| 436 | |
| 437 | const GrVkResource* bufferResource = buffer->resource(); |
| 438 | bufferResource->ref(); |
| 439 | fTexelBuffers.push(bufferResource); |
| 440 | |
| 441 | VkWriteDescriptorSet writeInfo; |
| 442 | memset(&writeInfo, 0, sizeof(VkWriteDescriptorSet)); |
| 443 | writeInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; |
| 444 | writeInfo.pNext = nullptr; |
| 445 | writeInfo.dstSet = fDescriptorSets[GrVkUniformHandler::kTexelBufferDescSet]; |
| 446 | writeInfo.dstBinding = i; |
| 447 | writeInfo.dstArrayElement = 0; |
| 448 | writeInfo.descriptorCount = 1; |
| 449 | writeInfo.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; |
| 450 | writeInfo.pImageInfo = nullptr; |
| 451 | writeInfo.pBufferInfo = nullptr; |
| 452 | VkBufferView vkBufferView = bufferView->bufferView(); |
| 453 | writeInfo.pTexelBufferView = &vkBufferView; |
| 454 | |
| 455 | GR_VK_CALL(gpu->vkInterface(), UpdateDescriptorSets(gpu->device(), |
| 456 | 1, |
| 457 | &writeInfo, |
| 458 | 0, |
| 459 | nullptr)); |
| 460 | } |
| 461 | } |
| 462 | |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 463 | void GrVkPipelineState::setRenderTargetState(const GrRenderTargetProxy* proxy) { |
| 464 | GrRenderTarget* rt = proxy->priv().peekRenderTarget(); |
| 465 | |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 466 | // Load the RT height uniform if it is needed to y-flip gl_FragCoord. |
| 467 | if (fBuiltinUniformHandles.fRTHeightUni.isValid() && |
Robert Phillips | 02bb6df | 2017-03-28 17:11:19 -0400 | [diff] [blame] | 468 | fRenderTargetState.fRenderTargetSize.fHeight != rt->height()) { |
| 469 | fDataManager.set1f(fBuiltinUniformHandles.fRTHeightUni, SkIntToScalar(rt->height())); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 470 | } |
| 471 | |
| 472 | // set RT adjustment |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 473 | SkISize size; |
| 474 | size.set(rt->width(), rt->height()); |
| 475 | SkASSERT(fBuiltinUniformHandles.fRTAdjustmentUni.isValid()); |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 476 | if (fRenderTargetState.fRenderTargetOrigin != proxy->origin() || |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 477 | fRenderTargetState.fRenderTargetSize != size) { |
| 478 | fRenderTargetState.fRenderTargetSize = size; |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 479 | fRenderTargetState.fRenderTargetOrigin = proxy->origin(); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 480 | |
| 481 | float rtAdjustmentVec[4]; |
| 482 | fRenderTargetState.getRTAdjustmentVec(rtAdjustmentVec); |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 483 | fDataManager.set4fv(fBuiltinUniformHandles.fRTAdjustmentUni, 1, rtAdjustmentVec); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 484 | } |
| 485 | } |
| 486 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 487 | void GrVkPipelineState::bind(const GrVkGpu* gpu, GrVkCommandBuffer* commandBuffer) { |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 488 | commandBuffer->bindPipeline(gpu, fPipeline); |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 489 | |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 490 | if (fGeometryUniformBuffer || fFragmentUniformBuffer) { |
| 491 | int dsIndex = GrVkUniformHandler::kUniformBufferDescSet; |
| 492 | commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, |
| 493 | dsIndex, 1, |
| 494 | &fDescriptorSets[dsIndex], 0, nullptr); |
| 495 | } |
| 496 | if (fNumSamplers) { |
| 497 | int dsIndex = GrVkUniformHandler::kSamplerDescSet; |
| 498 | commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, |
| 499 | dsIndex, 1, |
| 500 | &fDescriptorSets[dsIndex], 0, nullptr); |
| 501 | } |
| 502 | if (fNumTexelBuffers) { |
| 503 | int dsIndex = GrVkUniformHandler::kTexelBufferDescSet; |
| 504 | commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, |
| 505 | dsIndex, 1, |
| 506 | &fDescriptorSets[dsIndex], 0, nullptr); |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 507 | } |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 508 | } |
| 509 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 510 | void GrVkPipelineState::addUniformResources(GrVkCommandBuffer& commandBuffer) { |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 511 | if (fUniformDescriptorSet) { |
| 512 | commandBuffer.addRecycledResource(fUniformDescriptorSet); |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 513 | } |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 514 | if (fSamplerDescriptorSet) { |
| 515 | commandBuffer.addRecycledResource(fSamplerDescriptorSet); |
| 516 | } |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 517 | if (fTexelBufferDescriptorSet) { |
| 518 | commandBuffer.addRecycledResource(fTexelBufferDescriptorSet); |
| 519 | } |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 520 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 521 | if (fGeometryUniformBuffer.get()) { |
| 522 | commandBuffer.addRecycledResource(fGeometryUniformBuffer->resource()); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 523 | } |
| 524 | if (fFragmentUniformBuffer.get()) { |
egdaniel | 31bc7df | 2016-07-29 10:46:06 -0700 | [diff] [blame] | 525 | commandBuffer.addRecycledResource(fFragmentUniformBuffer->resource()); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 526 | } |
egdaniel | 31bc7df | 2016-07-29 10:46:06 -0700 | [diff] [blame] | 527 | |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 528 | for (int i = 0; i < fSamplers.count(); ++i) { |
| 529 | commandBuffer.addResource(fSamplers[i]); |
| 530 | } |
| 531 | |
| 532 | for (int i = 0; i < fTextureViews.count(); ++i) { |
| 533 | commandBuffer.addResource(fTextureViews[i]); |
| 534 | } |
| 535 | |
| 536 | for (int i = 0; i < fTextures.count(); ++i) { |
| 537 | commandBuffer.addResource(fTextures[i]); |
| 538 | } |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 539 | |
| 540 | for (int i = 0; i < fBufferViews.count(); ++i) { |
| 541 | commandBuffer.addResource(fBufferViews[i]); |
| 542 | } |
| 543 | |
| 544 | for (int i = 0; i < fTexelBuffers.count(); ++i) { |
| 545 | commandBuffer.addResource(fTexelBuffers[i]); |
| 546 | } |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 547 | } |