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" |
| 24 | #include "GrVkTexture.h" |
| 25 | #include "GrVkUniformBuffer.h" |
Brian Salomon | 1471df9 | 2018-06-08 10:49:00 -0400 | [diff] [blame] | 26 | #include "SkMipMap.h" |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 27 | #include "glsl/GrGLSLFragmentProcessor.h" |
| 28 | #include "glsl/GrGLSLGeometryProcessor.h" |
| 29 | #include "glsl/GrGLSLXferProcessor.h" |
| 30 | |
Brian Salomon | 1471df9 | 2018-06-08 10:49:00 -0400 | [diff] [blame] | 31 | GrVkPipelineState::GrVkPipelineState( |
| 32 | GrVkGpu* gpu, |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 33 | GrVkPipeline* pipeline, |
| 34 | VkPipelineLayout layout, |
| 35 | const GrVkDescriptorSetManager::Handle& samplerDSHandle, |
Brian Salomon | 1471df9 | 2018-06-08 10:49:00 -0400 | [diff] [blame] | 36 | const GrGLSLBuiltinUniformHandles& builtinUniformHandles, |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 37 | const UniformInfoArray& uniforms, |
| 38 | uint32_t geometryUniformSize, |
| 39 | uint32_t fragmentUniformSize, |
| 40 | uint32_t numSamplers, |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 41 | std::unique_ptr<GrGLSLPrimitiveProcessor> geometryProcessor, |
| 42 | std::unique_ptr<GrGLSLXferProcessor> xferProcessor, |
| 43 | std::unique_ptr<std::unique_ptr<GrGLSLFragmentProcessor>[]> fragmentProcessors, |
| 44 | int fragmentProcessorCnt) |
| 45 | : fPipeline(pipeline) |
Greg Daniel | 7d918fd | 2018-06-19 15:22:01 -0400 | [diff] [blame] | 46 | , fPipelineLayout(new GrVkPipelineLayout(layout)) |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 47 | , fUniformDescriptorSet(nullptr) |
| 48 | , fSamplerDescriptorSet(nullptr) |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 49 | , fSamplerDSHandle(samplerDSHandle) |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 50 | , fBuiltinUniformHandles(builtinUniformHandles) |
| 51 | , fGeometryProcessor(std::move(geometryProcessor)) |
| 52 | , fXferProcessor(std::move(xferProcessor)) |
| 53 | , fFragmentProcessors(std::move(fragmentProcessors)) |
| 54 | , fFragmentProcessorCnt(fragmentProcessorCnt) |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 55 | , fDataManager(uniforms, geometryUniformSize, fragmentUniformSize) { |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 56 | fDescriptorSets[0] = VK_NULL_HANDLE; |
| 57 | fDescriptorSets[1] = VK_NULL_HANDLE; |
Greg Daniel | 31ec144 | 2017-05-08 10:30:59 -0400 | [diff] [blame] | 58 | fDescriptorSets[2] = VK_NULL_HANDLE; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 59 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 60 | fGeometryUniformBuffer.reset(GrVkUniformBuffer::Create(gpu, geometryUniformSize)); |
jvanverth | 4c6e47a | 2016-07-22 10:34:52 -0700 | [diff] [blame] | 61 | fFragmentUniformBuffer.reset(GrVkUniformBuffer::Create(gpu, fragmentUniformSize)); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 62 | |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 63 | fNumSamplers = numSamplers; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 64 | } |
| 65 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 66 | GrVkPipelineState::~GrVkPipelineState() { |
Ethan Nicholas | 87f340e | 2017-01-03 14:32:01 -0500 | [diff] [blame] | 67 | // Must have freed all GPU resources before this is destroyed |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 68 | SkASSERT(!fPipeline); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 69 | SkASSERT(!fPipelineLayout); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 70 | } |
| 71 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 72 | void GrVkPipelineState::freeGPUResources(const GrVkGpu* gpu) { |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 73 | if (fPipeline) { |
| 74 | fPipeline->unref(gpu); |
| 75 | fPipeline = nullptr; |
| 76 | } |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 77 | |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 78 | if (fPipelineLayout) { |
Greg Daniel | 7d918fd | 2018-06-19 15:22:01 -0400 | [diff] [blame] | 79 | fPipelineLayout->unref(gpu); |
| 80 | fPipelineLayout = nullptr; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 81 | } |
| 82 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 83 | if (fGeometryUniformBuffer) { |
| 84 | fGeometryUniformBuffer->release(gpu); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 85 | } |
| 86 | |
| 87 | if (fFragmentUniformBuffer) { |
| 88 | fFragmentUniformBuffer->release(gpu); |
| 89 | } |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 90 | |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 91 | if (fUniformDescriptorSet) { |
| 92 | fUniformDescriptorSet->recycle(const_cast<GrVkGpu*>(gpu)); |
| 93 | fUniformDescriptorSet = nullptr; |
egdaniel | 778555c | 2016-05-02 06:50:36 -0700 | [diff] [blame] | 94 | } |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 95 | |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 96 | if (fSamplerDescriptorSet) { |
| 97 | fSamplerDescriptorSet->recycle(const_cast<GrVkGpu*>(gpu)); |
| 98 | fSamplerDescriptorSet = nullptr; |
| 99 | } |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 100 | } |
| 101 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 102 | void GrVkPipelineState::abandonGPUResources() { |
Greg Daniel | 7d918fd | 2018-06-19 15:22:01 -0400 | [diff] [blame] | 103 | if (fPipeline) { |
| 104 | fPipeline->unrefAndAbandon(); |
| 105 | fPipeline = nullptr; |
| 106 | } |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 107 | |
Greg Daniel | 7d918fd | 2018-06-19 15:22:01 -0400 | [diff] [blame] | 108 | if (fPipelineLayout) { |
| 109 | fPipelineLayout->unrefAndAbandon(); |
| 110 | fPipelineLayout = nullptr; |
| 111 | } |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 112 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 113 | fGeometryUniformBuffer->abandon(); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 114 | fFragmentUniformBuffer->abandon(); |
| 115 | |
egdaniel | a95220d | 2016-07-21 11:50:37 -0700 | [diff] [blame] | 116 | if (fUniformDescriptorSet) { |
| 117 | fUniformDescriptorSet->unrefAndAbandon(); |
| 118 | fUniformDescriptorSet = nullptr; |
egdaniel | 778555c | 2016-05-02 06:50:36 -0700 | [diff] [blame] | 119 | } |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 120 | |
| 121 | if (fSamplerDescriptorSet) { |
| 122 | fSamplerDescriptorSet->unrefAndAbandon(); |
| 123 | fSamplerDescriptorSet = nullptr; |
| 124 | } |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 125 | } |
| 126 | |
Brian Salomon | 5e81a12 | 2018-08-23 16:46:07 -0400 | [diff] [blame] | 127 | void GrVkPipelineState::setAndBindUniforms(GrVkGpu* gpu, |
| 128 | const GrPrimitiveProcessor& primProc, |
| 129 | const GrPipeline& pipeline, |
| 130 | GrVkCommandBuffer* commandBuffer) { |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 131 | this->setRenderTargetState(pipeline.proxy()); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 132 | |
bsalomon | a624bf3 | 2016-09-20 09:12:47 -0700 | [diff] [blame] | 133 | fGeometryProcessor->setData(fDataManager, primProc, |
| 134 | GrFragmentProcessor::CoordTransformIter(pipeline)); |
bsalomon | b58a2b4 | 2016-09-26 06:55:02 -0700 | [diff] [blame] | 135 | GrFragmentProcessor::Iter iter(pipeline); |
Brian Salomon | 4d3f517 | 2018-06-07 14:42:52 -0400 | [diff] [blame] | 136 | GrGLSLFragmentProcessor::Iter glslIter(fFragmentProcessors.get(), fFragmentProcessorCnt); |
bsalomon | b58a2b4 | 2016-09-26 06:55:02 -0700 | [diff] [blame] | 137 | const GrFragmentProcessor* fp = iter.next(); |
| 138 | GrGLSLFragmentProcessor* glslFP = glslIter.next(); |
| 139 | while (fp && glslFP) { |
| 140 | glslFP->setData(fDataManager, *fp); |
mtklein | 85552e4 | 2016-09-26 08:39:43 -0700 | [diff] [blame] | 141 | fp = iter.next(); |
| 142 | glslFP = glslIter.next(); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 143 | } |
bsalomon | b58a2b4 | 2016-09-26 06:55:02 -0700 | [diff] [blame] | 144 | SkASSERT(!fp && !glslFP); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 145 | |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 146 | { |
| 147 | SkIPoint offset; |
| 148 | GrTexture* dstTexture = pipeline.peekDstTexture(&offset); |
| 149 | |
| 150 | fXferProcessor->setData(fDataManager, pipeline.getXferProcessor(), dstTexture, offset); |
| 151 | } |
| 152 | |
Brian Salomon | 5e81a12 | 2018-08-23 16:46:07 -0400 | [diff] [blame] | 153 | // Get new descriptor set |
| 154 | if (fGeometryUniformBuffer || fFragmentUniformBuffer) { |
| 155 | int uniformDSIdx = GrVkUniformHandler::kUniformBufferDescSet; |
| 156 | if (fDataManager.uploadUniformBuffers( |
| 157 | gpu, fGeometryUniformBuffer.get(), fFragmentUniformBuffer.get()) || |
| 158 | !fUniformDescriptorSet) { |
| 159 | if (fUniformDescriptorSet) { |
| 160 | fUniformDescriptorSet->recycle(gpu); |
| 161 | } |
| 162 | fUniformDescriptorSet = gpu->resourceProvider().getUniformDescriptorSet(); |
| 163 | fDescriptorSets[uniformDSIdx] = fUniformDescriptorSet->descriptorSet(); |
| 164 | this->writeUniformBuffers(gpu); |
| 165 | } |
| 166 | commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, uniformDSIdx, 1, |
| 167 | &fDescriptorSets[uniformDSIdx], 0, nullptr); |
| 168 | if (fUniformDescriptorSet) { |
| 169 | commandBuffer->addRecycledResource(fUniformDescriptorSet); |
| 170 | } |
| 171 | if (fGeometryUniformBuffer) { |
| 172 | commandBuffer->addRecycledResource(fGeometryUniformBuffer->resource()); |
| 173 | } |
| 174 | if (fFragmentUniformBuffer) { |
| 175 | commandBuffer->addRecycledResource(fFragmentUniformBuffer->resource()); |
| 176 | } |
| 177 | } |
| 178 | } |
| 179 | |
| 180 | void GrVkPipelineState::setAndBindTextures(GrVkGpu* gpu, |
| 181 | const GrPrimitiveProcessor& primProc, |
| 182 | const GrPipeline& pipeline, |
| 183 | const GrTextureProxy* const primProcTextures[], |
| 184 | GrVkCommandBuffer* commandBuffer) { |
| 185 | SkASSERT(primProcTextures || !primProc.numTextureSamplers()); |
| 186 | |
| 187 | struct SamplerBindings { |
| 188 | GrSamplerState fState; |
| 189 | GrVkTexture* fTexture; |
| 190 | }; |
| 191 | SkAutoSTMalloc<8, SamplerBindings> samplerBindings(fNumSamplers); |
| 192 | int currTextureBinding = 0; |
| 193 | |
| 194 | fGeometryProcessor->setData(fDataManager, primProc, |
| 195 | GrFragmentProcessor::CoordTransformIter(pipeline)); |
| 196 | for (int i = 0; i < primProc.numTextureSamplers(); ++i) { |
| 197 | const auto& sampler = primProc.textureSampler(i); |
| 198 | auto texture = static_cast<GrVkTexture*>(primProcTextures[i]->peekTexture()); |
| 199 | samplerBindings[currTextureBinding++] = {sampler.samplerState(), texture}; |
| 200 | } |
| 201 | |
| 202 | GrFragmentProcessor::Iter iter(pipeline); |
| 203 | GrGLSLFragmentProcessor::Iter glslIter(fFragmentProcessors.get(), fFragmentProcessorCnt); |
| 204 | const GrFragmentProcessor* fp = iter.next(); |
| 205 | GrGLSLFragmentProcessor* glslFP = glslIter.next(); |
| 206 | while (fp && glslFP) { |
| 207 | for (int i = 0; i < fp->numTextureSamplers(); ++i) { |
| 208 | const auto& sampler = fp->textureSampler(i); |
| 209 | samplerBindings[currTextureBinding++] = |
| 210 | {sampler.samplerState(), static_cast<GrVkTexture*>(sampler.peekTexture())}; |
| 211 | } |
| 212 | fp = iter.next(); |
| 213 | glslFP = glslIter.next(); |
| 214 | } |
| 215 | SkASSERT(!fp && !glslFP); |
| 216 | |
Robert Phillips | bb581ce | 2017-05-29 15:05:15 -0400 | [diff] [blame] | 217 | if (GrTextureProxy* dstTextureProxy = pipeline.dstTextureProxy()) { |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 218 | samplerBindings[currTextureBinding++] = { |
| 219 | GrSamplerState::ClampNearest(), |
| 220 | static_cast<GrVkTexture*>(dstTextureProxy->peekTexture())}; |
Brian Salomon | 18dfa98 | 2017-04-03 16:57:43 -0400 | [diff] [blame] | 221 | } |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 222 | |
Brian Salomon | 5e81a12 | 2018-08-23 16:46:07 -0400 | [diff] [blame] | 223 | // Get new descriptor set |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 224 | SkASSERT(fNumSamplers == currTextureBinding); |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 225 | if (fNumSamplers) { |
egdaniel | 707bbd6 | 2016-07-26 07:19:47 -0700 | [diff] [blame] | 226 | if (fSamplerDescriptorSet) { |
| 227 | fSamplerDescriptorSet->recycle(gpu); |
| 228 | } |
| 229 | fSamplerDescriptorSet = gpu->resourceProvider().getSamplerDescriptorSet(fSamplerDSHandle); |
| 230 | int samplerDSIdx = GrVkUniformHandler::kSamplerDescSet; |
| 231 | fDescriptorSets[samplerDSIdx] = fSamplerDescriptorSet->descriptorSet(); |
Brian Salomon | 5e81a12 | 2018-08-23 16:46:07 -0400 | [diff] [blame] | 232 | for (int i = 0; i < fNumSamplers; ++i) { |
| 233 | const GrSamplerState& state = samplerBindings[i].fState; |
| 234 | GrVkTexture* texture = samplerBindings[i].fTexture; |
egdaniel | b4aa362 | 2016-04-06 13:47:08 -0700 | [diff] [blame] | 235 | |
Brian Salomon | 5e81a12 | 2018-08-23 16:46:07 -0400 | [diff] [blame] | 236 | const GrVkImageView* textureView = texture->textureView(); |
| 237 | GrVkSampler* sampler = gpu->resourceProvider().findOrCreateCompatibleSampler( |
| 238 | state, texture->texturePriv().maxMipMapLevel()); |
| 239 | |
| 240 | VkDescriptorImageInfo imageInfo; |
| 241 | memset(&imageInfo, 0, sizeof(VkDescriptorImageInfo)); |
| 242 | imageInfo.sampler = sampler->sampler(); |
| 243 | imageInfo.imageView = textureView->imageView(); |
| 244 | imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; |
| 245 | |
| 246 | VkWriteDescriptorSet writeInfo; |
| 247 | memset(&writeInfo, 0, sizeof(VkWriteDescriptorSet)); |
| 248 | writeInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; |
| 249 | writeInfo.pNext = nullptr; |
| 250 | writeInfo.dstSet = fDescriptorSets[GrVkUniformHandler::kSamplerDescSet]; |
| 251 | writeInfo.dstBinding = i; |
| 252 | writeInfo.dstArrayElement = 0; |
| 253 | writeInfo.descriptorCount = 1; |
| 254 | writeInfo.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; |
| 255 | writeInfo.pImageInfo = &imageInfo; |
| 256 | writeInfo.pBufferInfo = nullptr; |
| 257 | writeInfo.pTexelBufferView = nullptr; |
| 258 | |
| 259 | GR_VK_CALL(gpu->vkInterface(), |
| 260 | UpdateDescriptorSets(gpu->device(), 1, &writeInfo, 0, nullptr)); |
| 261 | commandBuffer->addResource(sampler); |
| 262 | sampler->unref(gpu); |
| 263 | commandBuffer->addResource(samplerBindings[i].fTexture->textureView()); |
| 264 | commandBuffer->addResource(samplerBindings[i].fTexture->resource()); |
egdaniel | 7cbffda | 2016-04-08 13:27:53 -0700 | [diff] [blame] | 265 | } |
Brian Salomon | 5e81a12 | 2018-08-23 16:46:07 -0400 | [diff] [blame] | 266 | |
| 267 | commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, samplerDSIdx, 1, |
| 268 | &fDescriptorSets[samplerDSIdx], 0, nullptr); |
| 269 | commandBuffer->addRecycledResource(fSamplerDescriptorSet); |
egdaniel | b4aa362 | 2016-04-06 13:47:08 -0700 | [diff] [blame] | 270 | } |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 271 | } |
| 272 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 273 | void set_uniform_descriptor_writes(VkWriteDescriptorSet* descriptorWrite, |
| 274 | VkDescriptorBufferInfo* bufferInfo, |
| 275 | const GrVkUniformBuffer* buffer, |
| 276 | VkDescriptorSet descriptorSet, |
| 277 | uint32_t binding) { |
| 278 | |
| 279 | memset(bufferInfo, 0, sizeof(VkDescriptorBufferInfo)); |
| 280 | bufferInfo->buffer = buffer->buffer(); |
| 281 | bufferInfo->offset = buffer->offset(); |
| 282 | bufferInfo->range = buffer->size(); |
| 283 | |
| 284 | memset(descriptorWrite, 0, sizeof(VkWriteDescriptorSet)); |
| 285 | descriptorWrite->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; |
| 286 | descriptorWrite->pNext = nullptr; |
Greg Daniel | 783c436 | 2017-05-04 17:29:09 -0400 | [diff] [blame] | 287 | descriptorWrite->dstSet = descriptorSet; |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 288 | descriptorWrite->dstBinding = binding; |
| 289 | descriptorWrite->dstArrayElement = 0; |
| 290 | descriptorWrite->descriptorCount = 1; |
| 291 | descriptorWrite->descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; |
| 292 | descriptorWrite->pImageInfo = nullptr; |
| 293 | descriptorWrite->pBufferInfo = bufferInfo; |
| 294 | descriptorWrite->pTexelBufferView = nullptr; |
| 295 | } |
| 296 | |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 297 | void GrVkPipelineState::writeUniformBuffers(const GrVkGpu* gpu) { |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 298 | VkWriteDescriptorSet descriptorWrites[3]; |
| 299 | VkDescriptorBufferInfo bufferInfos[3]; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 300 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 301 | uint32_t writeCount = 0; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 302 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 303 | // Geometry Uniform Buffer |
| 304 | if (fGeometryUniformBuffer.get()) { |
| 305 | set_uniform_descriptor_writes(&descriptorWrites[writeCount], |
| 306 | &bufferInfos[writeCount], |
| 307 | fGeometryUniformBuffer.get(), |
| 308 | fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet], |
| 309 | GrVkUniformHandler::kGeometryBinding); |
| 310 | ++writeCount; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 311 | } |
| 312 | |
| 313 | // Fragment Uniform Buffer |
| 314 | if (fFragmentUniformBuffer.get()) { |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 315 | set_uniform_descriptor_writes(&descriptorWrites[writeCount], |
| 316 | &bufferInfos[writeCount], |
| 317 | fFragmentUniformBuffer.get(), |
| 318 | fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet], |
| 319 | GrVkUniformHandler::kFragBinding); |
| 320 | ++writeCount; |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 321 | } |
| 322 | |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 323 | if (writeCount) { |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 324 | GR_VK_CALL(gpu->vkInterface(), UpdateDescriptorSets(gpu->device(), |
Greg Daniel | 18f9602 | 2017-05-04 15:09:03 -0400 | [diff] [blame] | 325 | writeCount, |
| 326 | descriptorWrites, |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 327 | 0, nullptr)); |
| 328 | } |
| 329 | } |
| 330 | |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 331 | void GrVkPipelineState::setRenderTargetState(const GrRenderTargetProxy* proxy) { |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 332 | GrRenderTarget* rt = proxy->peekRenderTarget(); |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 333 | |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 334 | // Load the RT height uniform if it is needed to y-flip gl_FragCoord. |
Greg Daniel | e6ab998 | 2018-08-22 13:56:32 +0000 | [diff] [blame] | 335 | if (fBuiltinUniformHandles.fRTHeightUni.isValid() && |
| 336 | fRenderTargetState.fRenderTargetSize.fHeight != rt->height()) { |
| 337 | fDataManager.set1f(fBuiltinUniformHandles.fRTHeightUni, SkIntToScalar(rt->height())); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 338 | } |
| 339 | |
| 340 | // set RT adjustment |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 341 | SkISize size; |
| 342 | size.set(rt->width(), rt->height()); |
| 343 | SkASSERT(fBuiltinUniformHandles.fRTAdjustmentUni.isValid()); |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 344 | if (fRenderTargetState.fRenderTargetOrigin != proxy->origin() || |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 345 | fRenderTargetState.fRenderTargetSize != size) { |
| 346 | fRenderTargetState.fRenderTargetSize = size; |
Robert Phillips | 2890fbf | 2017-07-26 15:48:41 -0400 | [diff] [blame] | 347 | fRenderTargetState.fRenderTargetOrigin = proxy->origin(); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 348 | |
| 349 | float rtAdjustmentVec[4]; |
| 350 | fRenderTargetState.getRTAdjustmentVec(rtAdjustmentVec); |
egdaniel | 22281c1 | 2016-03-23 13:49:40 -0700 | [diff] [blame] | 351 | fDataManager.set4fv(fBuiltinUniformHandles.fRTAdjustmentUni, 1, rtAdjustmentVec); |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 352 | } |
| 353 | } |
| 354 | |
Brian Salomon | 5e81a12 | 2018-08-23 16:46:07 -0400 | [diff] [blame] | 355 | void GrVkPipelineState::bindPipeline(const GrVkGpu* gpu, GrVkCommandBuffer* commandBuffer) { |
jvanverth | 992ad36 | 2016-02-26 09:21:02 -0800 | [diff] [blame] | 356 | commandBuffer->bindPipeline(gpu, fPipeline); |
egdaniel | c2dc1b2 | 2016-03-18 13:18:23 -0700 | [diff] [blame] | 357 | } |