src/gpu/vk/GrVkPipelineState.cpp - skia - Git at Google

 /*
 * 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 "GrVkPipelineState.h"
 #include "GrContext.h"
 #include "GrContextPriv.h"
 #include "GrPipeline.h"
 #include "GrRenderTarget.h"
 #include "GrTexturePriv.h"
 #include "GrVkBufferView.h"
 #include "GrVkCommandBuffer.h"
 #include "GrVkDescriptorPool.h"
 #include "GrVkDescriptorSet.h"
 #include "GrVkGpu.h"
 #include "GrVkImageView.h"
 #include "GrVkMemory.h"
 #include "GrVkPipeline.h"
 #include "GrVkPipelineLayout.h"
 #include "GrVkSampler.h"
 #include "GrVkTexture.h"
 #include "GrVkUniformBuffer.h"
 #include "SkMipMap.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLXferProcessor.h"

 GrVkPipelineState::GrVkPipelineState(
         GrVkGpu* gpu,
         GrVkPipeline* pipeline,
         VkPipelineLayout layout,
         const GrVkDescriptorSetManager::Handle& samplerDSHandle,
         const GrGLSLBuiltinUniformHandles& builtinUniformHandles,
         const UniformInfoArray& uniforms,
         uint32_t geometryUniformSize,
         uint32_t fragmentUniformSize,
         const UniformInfoArray& samplers,
         std::unique_ptr<GrGLSLPrimitiveProcessor> geometryProcessor,
         std::unique_ptr<GrGLSLXferProcessor> xferProcessor,
         std::unique_ptr<std::unique_ptr<GrGLSLFragmentProcessor>[]> fragmentProcessors,
         int fragmentProcessorCnt)
         : fPipeline(pipeline)
         , fPipelineLayout(new GrVkPipelineLayout(layout))
         , fUniformDescriptorSet(nullptr)
         , fSamplerDescriptorSet(nullptr)
         , fSamplerDSHandle(samplerDSHandle)
         , fBuiltinUniformHandles(builtinUniformHandles)
         , fGeometryProcessor(std::move(geometryProcessor))
         , fXferProcessor(std::move(xferProcessor))
         , fFragmentProcessors(std::move(fragmentProcessors))
         , fFragmentProcessorCnt(fragmentProcessorCnt)
         , fDataManager(uniforms, geometryUniformSize, fragmentUniformSize) {
     fDescriptorSets[0] = VK_NULL_HANDLE;
     fDescriptorSets[1] = VK_NULL_HANDLE;
     fDescriptorSets[2] = VK_NULL_HANDLE;

     fGeometryUniformBuffer.reset(GrVkUniformBuffer::Create(gpu, geometryUniformSize));
     fFragmentUniformBuffer.reset(GrVkUniformBuffer::Create(gpu, fragmentUniformSize));

     fNumSamplers = samplers.count();

     for (int i = 0; i < fNumSamplers; ++i) {
         // We store the immutable samplers here and take ownership of the ref from the
         // GrVkUnformHandler.
         fImmutableSamplers.push_back(samplers[i].fImmutableSampler);
     }
 }

 GrVkPipelineState::~GrVkPipelineState() {
     // Must have freed all GPU resources before this is destroyed
     SkASSERT(!fPipeline);
     SkASSERT(!fPipelineLayout);
 }

 void GrVkPipelineState::freeGPUResources(GrVkGpu* gpu) {
     if (fPipeline) {
         fPipeline->unref(gpu);
         fPipeline = nullptr;
     }

     if (fPipelineLayout) {
         fPipelineLayout->unref(gpu);
         fPipelineLayout = nullptr;
     }

     if (fGeometryUniformBuffer) {
         fGeometryUniformBuffer->release(gpu);
         fGeometryUniformBuffer.reset();
     }

     if (fFragmentUniformBuffer) {
         fFragmentUniformBuffer->release(gpu);
         fFragmentUniformBuffer.reset();
     }

     if (fUniformDescriptorSet) {
         fUniformDescriptorSet->recycle(const_cast<GrVkGpu*>(gpu));
         fUniformDescriptorSet = nullptr;
     }

     if (fSamplerDescriptorSet) {
         fSamplerDescriptorSet->recycle(const_cast<GrVkGpu*>(gpu));
         fSamplerDescriptorSet = nullptr;
     }
 }

 void GrVkPipelineState::abandonGPUResources() {
     if (fPipeline) {
         fPipeline->unrefAndAbandon();
         fPipeline = nullptr;
     }

     if (fPipelineLayout) {
         fPipelineLayout->unrefAndAbandon();
         fPipelineLayout = nullptr;
     }

     if (fGeometryUniformBuffer) {
         fGeometryUniformBuffer->abandon();
         fGeometryUniformBuffer.reset();
     }

     if (fFragmentUniformBuffer) {
         fFragmentUniformBuffer->abandon();
         fFragmentUniformBuffer.reset();
     }

     if (fUniformDescriptorSet) {
         fUniformDescriptorSet->unrefAndAbandon();
         fUniformDescriptorSet = nullptr;
     }

     if (fSamplerDescriptorSet) {
         fSamplerDescriptorSet->unrefAndAbandon();
         fSamplerDescriptorSet = nullptr;
     }
 }

 void GrVkPipelineState::setAndBindUniforms(GrVkGpu* gpu,
                                            const GrRenderTarget* renderTarget,
                                            GrSurfaceOrigin origin,
                                            const GrPrimitiveProcessor& primProc,
                                            const GrPipeline& pipeline,
                                            GrVkCommandBuffer* commandBuffer) {
     this->setRenderTargetState(renderTarget, origin);

     fGeometryProcessor->setData(fDataManager, primProc,
                                 GrFragmentProcessor::CoordTransformIter(pipeline));
     GrFragmentProcessor::Iter iter(pipeline);
     GrGLSLFragmentProcessor::Iter glslIter(fFragmentProcessors.get(), fFragmentProcessorCnt);
     const GrFragmentProcessor* fp = iter.next();
     GrGLSLFragmentProcessor* glslFP = glslIter.next();
     while (fp && glslFP) {
         glslFP->setData(fDataManager, *fp);
         fp = iter.next();
         glslFP = glslIter.next();
     }
     SkASSERT(!fp && !glslFP);

     {
         SkIPoint offset;
         GrTexture* dstTexture = pipeline.peekDstTexture(&offset);

         fXferProcessor->setData(fDataManager, pipeline.getXferProcessor(), dstTexture, offset);
     }

     // Get new descriptor set
     if (fGeometryUniformBuffer || fFragmentUniformBuffer) {
         int uniformDSIdx = GrVkUniformHandler::kUniformBufferDescSet;
         if (fDataManager.uploadUniformBuffers(
                     gpu, fGeometryUniformBuffer.get(), fFragmentUniformBuffer.get()) ||
             !fUniformDescriptorSet) {
             if (fUniformDescriptorSet) {
                 fUniformDescriptorSet->recycle(gpu);
             }
             fUniformDescriptorSet = gpu->resourceProvider().getUniformDescriptorSet();
             fDescriptorSets[uniformDSIdx] = fUniformDescriptorSet->descriptorSet();
             this->writeUniformBuffers(gpu);
         }
         commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, uniformDSIdx, 1,
                                           &fDescriptorSets[uniformDSIdx], 0, nullptr);
         if (fUniformDescriptorSet) {
             commandBuffer->addRecycledResource(fUniformDescriptorSet);
         }
         if (fGeometryUniformBuffer) {
             commandBuffer->addRecycledResource(fGeometryUniformBuffer->resource());
         }
         if (fFragmentUniformBuffer) {
             commandBuffer->addRecycledResource(fFragmentUniformBuffer->resource());
         }
     }
 }

 void GrVkPipelineState::setAndBindTextures(GrVkGpu* gpu,
                                            const GrPrimitiveProcessor& primProc,
                                            const GrPipeline& pipeline,
                                            const GrTextureProxy* const primProcTextures[],
                                            GrVkCommandBuffer* commandBuffer) {
     SkASSERT(primProcTextures || !primProc.numTextureSamplers());

     struct SamplerBindings {
         GrSamplerState fState;
         GrVkTexture* fTexture;
     };
     SkAutoSTMalloc<8, SamplerBindings> samplerBindings(fNumSamplers);
     int currTextureBinding = 0;

     fGeometryProcessor->setData(fDataManager, primProc,
                                 GrFragmentProcessor::CoordTransformIter(pipeline));
     for (int i = 0; i < primProc.numTextureSamplers(); ++i) {
         const auto& sampler = primProc.textureSampler(i);
         auto texture = static_cast<GrVkTexture*>(primProcTextures[i]->peekTexture());
         samplerBindings[currTextureBinding++] = {sampler.samplerState(), texture};
     }

     GrFragmentProcessor::Iter iter(pipeline);
     GrGLSLFragmentProcessor::Iter glslIter(fFragmentProcessors.get(), fFragmentProcessorCnt);
     const GrFragmentProcessor* fp = iter.next();
     GrGLSLFragmentProcessor* glslFP = glslIter.next();
     while (fp && glslFP) {
         for (int i = 0; i < fp->numTextureSamplers(); ++i) {
             const auto& sampler = fp->textureSampler(i);
             samplerBindings[currTextureBinding++] =
                     {sampler.samplerState(), static_cast<GrVkTexture*>(sampler.peekTexture())};
         }
         fp = iter.next();
         glslFP = glslIter.next();
     }
     SkASSERT(!fp && !glslFP);

     if (GrTextureProxy* dstTextureProxy = pipeline.dstTextureProxy()) {
         samplerBindings[currTextureBinding++] = {
                 GrSamplerState::ClampNearest(),
                 static_cast<GrVkTexture*>(dstTextureProxy->peekTexture())};
     }

     // Get new descriptor set
     SkASSERT(fNumSamplers == currTextureBinding);
     if (fNumSamplers) {
         if (fSamplerDescriptorSet) {
             fSamplerDescriptorSet->recycle(gpu);
         }
         fSamplerDescriptorSet = gpu->resourceProvider().getSamplerDescriptorSet(fSamplerDSHandle);
         int samplerDSIdx = GrVkUniformHandler::kSamplerDescSet;
         fDescriptorSets[samplerDSIdx] = fSamplerDescriptorSet->descriptorSet();
         for (int i = 0; i < fNumSamplers; ++i) {
             const GrSamplerState& state = samplerBindings[i].fState;
             GrVkTexture* texture = samplerBindings[i].fTexture;

             const GrVkImageView* textureView = texture->textureView();
             const GrVkSampler* sampler = nullptr;
             if (fImmutableSamplers[i]) {
                 sampler = fImmutableSamplers[i];
             } else {
                 sampler = gpu->resourceProvider().findOrCreateCompatibleSampler(
                     state, texture->ycbcrConversionInfo());
             }
             SkASSERT(sampler);

             VkDescriptorImageInfo imageInfo;
             memset(&imageInfo, 0, sizeof(VkDescriptorImageInfo));
             imageInfo.sampler = sampler->sampler();
             imageInfo.imageView = textureView->imageView();
             imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

             VkWriteDescriptorSet writeInfo;
             memset(&writeInfo, 0, sizeof(VkWriteDescriptorSet));
             writeInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
             writeInfo.pNext = nullptr;
             writeInfo.dstSet = fDescriptorSets[GrVkUniformHandler::kSamplerDescSet];
             writeInfo.dstBinding = i;
             writeInfo.dstArrayElement = 0;
             writeInfo.descriptorCount = 1;
             writeInfo.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
             writeInfo.pImageInfo = &imageInfo;
             writeInfo.pBufferInfo = nullptr;
             writeInfo.pTexelBufferView = nullptr;

             GR_VK_CALL(gpu->vkInterface(),
                        UpdateDescriptorSets(gpu->device(), 1, &writeInfo, 0, nullptr));
             commandBuffer->addResource(sampler);
             if (!fImmutableSamplers[i]) {
                 sampler->unref(gpu);
             }
             commandBuffer->addResource(samplerBindings[i].fTexture->textureView());
             commandBuffer->addResource(samplerBindings[i].fTexture->resource());
         }

         commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, samplerDSIdx, 1,
                                           &fDescriptorSets[samplerDSIdx], 0, nullptr);
         commandBuffer->addRecycledResource(fSamplerDescriptorSet);
     }
 }

 void set_uniform_descriptor_writes(VkWriteDescriptorSet* descriptorWrite,
                                    VkDescriptorBufferInfo* bufferInfo,
                                    const GrVkUniformBuffer* buffer,
                                    VkDescriptorSet descriptorSet,
                                    uint32_t binding) {

     memset(bufferInfo, 0, sizeof(VkDescriptorBufferInfo));
     bufferInfo->buffer = buffer->buffer();
     bufferInfo->offset = buffer->offset();
     bufferInfo->range = buffer->size();

     memset(descriptorWrite, 0, sizeof(VkWriteDescriptorSet));
     descriptorWrite->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
     descriptorWrite->pNext = nullptr;
     descriptorWrite->dstSet = descriptorSet;
     descriptorWrite->dstBinding = binding;
     descriptorWrite->dstArrayElement = 0;
     descriptorWrite->descriptorCount = 1;
     descriptorWrite->descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
     descriptorWrite->pImageInfo = nullptr;
     descriptorWrite->pBufferInfo = bufferInfo;
     descriptorWrite->pTexelBufferView = nullptr;
 }

 void GrVkPipelineState::writeUniformBuffers(const GrVkGpu* gpu) {
     VkWriteDescriptorSet descriptorWrites[3];
     VkDescriptorBufferInfo bufferInfos[3];

     uint32_t writeCount = 0;

     // Geometry Uniform Buffer
     if (fGeometryUniformBuffer.get()) {
         set_uniform_descriptor_writes(&descriptorWrites[writeCount],
                                       &bufferInfos[writeCount],
                                       fGeometryUniformBuffer.get(),
                                       fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet],
                                       GrVkUniformHandler::kGeometryBinding);
         ++writeCount;
     }

     // Fragment Uniform Buffer
     if (fFragmentUniformBuffer.get()) {
         set_uniform_descriptor_writes(&descriptorWrites[writeCount],
                                       &bufferInfos[writeCount],
                                       fFragmentUniformBuffer.get(),
                                       fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet],
                                       GrVkUniformHandler::kFragBinding);
         ++writeCount;
     }

     if (writeCount) {
         GR_VK_CALL(gpu->vkInterface(), UpdateDescriptorSets(gpu->device(),
                                                             writeCount,
                                                             descriptorWrites,
                                                             0, nullptr));
     }
 }

 void GrVkPipelineState::setRenderTargetState(const GrRenderTarget* rt, GrSurfaceOrigin origin) {

     // Load the RT height uniform if it is needed to y-flip gl_FragCoord.
     if (fBuiltinUniformHandles.fRTHeightUni.isValid() &&
         fRenderTargetState.fRenderTargetSize.fHeight != rt->height()) {
         fDataManager.set1f(fBuiltinUniformHandles.fRTHeightUni, SkIntToScalar(rt->height()));
     }

     // set RT adjustment
     SkISize size;
     size.set(rt->width(), rt->height());
     SkASSERT(fBuiltinUniformHandles.fRTAdjustmentUni.isValid());
     if (fRenderTargetState.fRenderTargetOrigin != origin ||
         fRenderTargetState.fRenderTargetSize != size) {
         fRenderTargetState.fRenderTargetSize = size;
         fRenderTargetState.fRenderTargetOrigin = origin;

         float rtAdjustmentVec[4];
         fRenderTargetState.getRTAdjustmentVec(rtAdjustmentVec);
         fDataManager.set4fv(fBuiltinUniformHandles.fRTAdjustmentUni, 1, rtAdjustmentVec);
     }
 }

 void GrVkPipelineState::bindPipeline(const GrVkGpu* gpu, GrVkCommandBuffer* commandBuffer) {
     commandBuffer->bindPipeline(gpu, fPipeline);
 }
	/*
	* 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 "GrVkPipelineState.h"
	#include "GrContext.h"
	#include "GrContextPriv.h"
	#include "GrPipeline.h"
	#include "GrRenderTarget.h"
	#include "GrTexturePriv.h"
	#include "GrVkBufferView.h"
	#include "GrVkCommandBuffer.h"
	#include "GrVkDescriptorPool.h"
	#include "GrVkDescriptorSet.h"
	#include "GrVkGpu.h"
	#include "GrVkImageView.h"
	#include "GrVkMemory.h"
	#include "GrVkPipeline.h"
	#include "GrVkPipelineLayout.h"
	#include "GrVkSampler.h"
	#include "GrVkTexture.h"
	#include "GrVkUniformBuffer.h"
	#include "SkMipMap.h"
	#include "glsl/GrGLSLFragmentProcessor.h"
	#include "glsl/GrGLSLGeometryProcessor.h"
	#include "glsl/GrGLSLXferProcessor.h"

	GrVkPipelineState::GrVkPipelineState(
	GrVkGpu* gpu,
	GrVkPipeline* pipeline,
	VkPipelineLayout layout,
	const GrVkDescriptorSetManager::Handle& samplerDSHandle,
	const GrGLSLBuiltinUniformHandles& builtinUniformHandles,
	const UniformInfoArray& uniforms,
	uint32_t geometryUniformSize,
	uint32_t fragmentUniformSize,
	const UniformInfoArray& samplers,
	std::unique_ptr<GrGLSLPrimitiveProcessor> geometryProcessor,
	std::unique_ptr<GrGLSLXferProcessor> xferProcessor,
	std::unique_ptr<std::unique_ptr<GrGLSLFragmentProcessor>[]> fragmentProcessors,
	int fragmentProcessorCnt)
	: fPipeline(pipeline)
	, fPipelineLayout(new GrVkPipelineLayout(layout))
	, fUniformDescriptorSet(nullptr)
	, fSamplerDescriptorSet(nullptr)
	, fSamplerDSHandle(samplerDSHandle)
	, fBuiltinUniformHandles(builtinUniformHandles)
	, fGeometryProcessor(std::move(geometryProcessor))
	, fXferProcessor(std::move(xferProcessor))
	, fFragmentProcessors(std::move(fragmentProcessors))
	, fFragmentProcessorCnt(fragmentProcessorCnt)
	, fDataManager(uniforms, geometryUniformSize, fragmentUniformSize) {
	fDescriptorSets[0] = VK_NULL_HANDLE;
	fDescriptorSets[1] = VK_NULL_HANDLE;
	fDescriptorSets[2] = VK_NULL_HANDLE;

	fGeometryUniformBuffer.reset(GrVkUniformBuffer::Create(gpu, geometryUniformSize));
	fFragmentUniformBuffer.reset(GrVkUniformBuffer::Create(gpu, fragmentUniformSize));

	fNumSamplers = samplers.count();

	for (int i = 0; i < fNumSamplers; ++i) {
	// We store the immutable samplers here and take ownership of the ref from the
	// GrVkUnformHandler.
	fImmutableSamplers.push_back(samplers[i].fImmutableSampler);
	}
	}

	GrVkPipelineState::~GrVkPipelineState() {
	// Must have freed all GPU resources before this is destroyed
	SkASSERT(!fPipeline);
	SkASSERT(!fPipelineLayout);
	}

	void GrVkPipelineState::freeGPUResources(GrVkGpu* gpu) {
	if (fPipeline) {
	fPipeline->unref(gpu);
	fPipeline = nullptr;
	}

	if (fPipelineLayout) {
	fPipelineLayout->unref(gpu);
	fPipelineLayout = nullptr;
	}

	if (fGeometryUniformBuffer) {
	fGeometryUniformBuffer->release(gpu);
	fGeometryUniformBuffer.reset();
	}

	if (fFragmentUniformBuffer) {
	fFragmentUniformBuffer->release(gpu);
	fFragmentUniformBuffer.reset();
	}

	if (fUniformDescriptorSet) {
	fUniformDescriptorSet->recycle(const_cast<GrVkGpu*>(gpu));
	fUniformDescriptorSet = nullptr;
	}

	if (fSamplerDescriptorSet) {
	fSamplerDescriptorSet->recycle(const_cast<GrVkGpu*>(gpu));
	fSamplerDescriptorSet = nullptr;
	}
	}

	void GrVkPipelineState::abandonGPUResources() {
	if (fPipeline) {
	fPipeline->unrefAndAbandon();
	fPipeline = nullptr;
	}

	if (fPipelineLayout) {
	fPipelineLayout->unrefAndAbandon();
	fPipelineLayout = nullptr;
	}

	if (fGeometryUniformBuffer) {
	fGeometryUniformBuffer->abandon();
	fGeometryUniformBuffer.reset();
	}

	if (fFragmentUniformBuffer) {
	fFragmentUniformBuffer->abandon();
	fFragmentUniformBuffer.reset();
	}

	if (fUniformDescriptorSet) {
	fUniformDescriptorSet->unrefAndAbandon();
	fUniformDescriptorSet = nullptr;
	}

	if (fSamplerDescriptorSet) {
	fSamplerDescriptorSet->unrefAndAbandon();
	fSamplerDescriptorSet = nullptr;
	}
	}

	void GrVkPipelineState::setAndBindUniforms(GrVkGpu* gpu,
	const GrRenderTarget* renderTarget,
	GrSurfaceOrigin origin,
	const GrPrimitiveProcessor& primProc,
	const GrPipeline& pipeline,
	GrVkCommandBuffer* commandBuffer) {
	this->setRenderTargetState(renderTarget, origin);

	fGeometryProcessor->setData(fDataManager, primProc,
	GrFragmentProcessor::CoordTransformIter(pipeline));
	GrFragmentProcessor::Iter iter(pipeline);
	GrGLSLFragmentProcessor::Iter glslIter(fFragmentProcessors.get(), fFragmentProcessorCnt);
	const GrFragmentProcessor* fp = iter.next();
	GrGLSLFragmentProcessor* glslFP = glslIter.next();
	while (fp && glslFP) {
	glslFP->setData(fDataManager, *fp);
	fp = iter.next();
	glslFP = glslIter.next();
	}
	SkASSERT(!fp && !glslFP);

	{
	SkIPoint offset;
	GrTexture* dstTexture = pipeline.peekDstTexture(&offset);

	fXferProcessor->setData(fDataManager, pipeline.getXferProcessor(), dstTexture, offset);
	}

	// Get new descriptor set
	if (fGeometryUniformBuffer \|\| fFragmentUniformBuffer) {
	int uniformDSIdx = GrVkUniformHandler::kUniformBufferDescSet;
	if (fDataManager.uploadUniformBuffers(
	gpu, fGeometryUniformBuffer.get(), fFragmentUniformBuffer.get()) \|\|
	!fUniformDescriptorSet) {
	if (fUniformDescriptorSet) {
	fUniformDescriptorSet->recycle(gpu);
	}
	fUniformDescriptorSet = gpu->resourceProvider().getUniformDescriptorSet();
	fDescriptorSets[uniformDSIdx] = fUniformDescriptorSet->descriptorSet();
	this->writeUniformBuffers(gpu);
	}
	commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, uniformDSIdx, 1,
	&fDescriptorSets[uniformDSIdx], 0, nullptr);
	if (fUniformDescriptorSet) {
	commandBuffer->addRecycledResource(fUniformDescriptorSet);
	}
	if (fGeometryUniformBuffer) {
	commandBuffer->addRecycledResource(fGeometryUniformBuffer->resource());
	}
	if (fFragmentUniformBuffer) {
	commandBuffer->addRecycledResource(fFragmentUniformBuffer->resource());
	}
	}
	}

	void GrVkPipelineState::setAndBindTextures(GrVkGpu* gpu,
	const GrPrimitiveProcessor& primProc,
	const GrPipeline& pipeline,
	const GrTextureProxy* const primProcTextures[],
	GrVkCommandBuffer* commandBuffer) {
	SkASSERT(primProcTextures \|\| !primProc.numTextureSamplers());

	struct SamplerBindings {
	GrSamplerState fState;
	GrVkTexture* fTexture;
	};
	SkAutoSTMalloc<8, SamplerBindings> samplerBindings(fNumSamplers);
	int currTextureBinding = 0;

	fGeometryProcessor->setData(fDataManager, primProc,
	GrFragmentProcessor::CoordTransformIter(pipeline));
	for (int i = 0; i < primProc.numTextureSamplers(); ++i) {
	const auto& sampler = primProc.textureSampler(i);
	auto texture = static_cast<GrVkTexture*>(primProcTextures[i]->peekTexture());
	samplerBindings[currTextureBinding++] = {sampler.samplerState(), texture};
	}

	GrFragmentProcessor::Iter iter(pipeline);
	GrGLSLFragmentProcessor::Iter glslIter(fFragmentProcessors.get(), fFragmentProcessorCnt);
	const GrFragmentProcessor* fp = iter.next();
	GrGLSLFragmentProcessor* glslFP = glslIter.next();
	while (fp && glslFP) {
	for (int i = 0; i < fp->numTextureSamplers(); ++i) {
	const auto& sampler = fp->textureSampler(i);
	samplerBindings[currTextureBinding++] =
	{sampler.samplerState(), static_cast<GrVkTexture*>(sampler.peekTexture())};
	}
	fp = iter.next();
	glslFP = glslIter.next();
	}
	SkASSERT(!fp && !glslFP);

	if (GrTextureProxy* dstTextureProxy = pipeline.dstTextureProxy()) {
	samplerBindings[currTextureBinding++] = {
	GrSamplerState::ClampNearest(),
	static_cast<GrVkTexture*>(dstTextureProxy->peekTexture())};
	}

	// Get new descriptor set
	SkASSERT(fNumSamplers == currTextureBinding);
	if (fNumSamplers) {
	if (fSamplerDescriptorSet) {
	fSamplerDescriptorSet->recycle(gpu);
	}
	fSamplerDescriptorSet = gpu->resourceProvider().getSamplerDescriptorSet(fSamplerDSHandle);
	int samplerDSIdx = GrVkUniformHandler::kSamplerDescSet;
	fDescriptorSets[samplerDSIdx] = fSamplerDescriptorSet->descriptorSet();
	for (int i = 0; i < fNumSamplers; ++i) {
	const GrSamplerState& state = samplerBindings[i].fState;
	GrVkTexture* texture = samplerBindings[i].fTexture;

	const GrVkImageView* textureView = texture->textureView();
	const GrVkSampler* sampler = nullptr;
	if (fImmutableSamplers[i]) {
	sampler = fImmutableSamplers[i];
	} else {
	sampler = gpu->resourceProvider().findOrCreateCompatibleSampler(
	state, texture->ycbcrConversionInfo());
	}
	SkASSERT(sampler);

	VkDescriptorImageInfo imageInfo;
	memset(&imageInfo, 0, sizeof(VkDescriptorImageInfo));
	imageInfo.sampler = sampler->sampler();
	imageInfo.imageView = textureView->imageView();
	imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;

	VkWriteDescriptorSet writeInfo;
	memset(&writeInfo, 0, sizeof(VkWriteDescriptorSet));
	writeInfo.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
	writeInfo.pNext = nullptr;
	writeInfo.dstSet = fDescriptorSets[GrVkUniformHandler::kSamplerDescSet];
	writeInfo.dstBinding = i;
	writeInfo.dstArrayElement = 0;
	writeInfo.descriptorCount = 1;
	writeInfo.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
	writeInfo.pImageInfo = &imageInfo;
	writeInfo.pBufferInfo = nullptr;
	writeInfo.pTexelBufferView = nullptr;

	GR_VK_CALL(gpu->vkInterface(),
	UpdateDescriptorSets(gpu->device(), 1, &writeInfo, 0, nullptr));
	commandBuffer->addResource(sampler);
	if (!fImmutableSamplers[i]) {
	sampler->unref(gpu);
	}
	commandBuffer->addResource(samplerBindings[i].fTexture->textureView());
	commandBuffer->addResource(samplerBindings[i].fTexture->resource());
	}

	commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, samplerDSIdx, 1,
	&fDescriptorSets[samplerDSIdx], 0, nullptr);
	commandBuffer->addRecycledResource(fSamplerDescriptorSet);
	}
	}

	void set_uniform_descriptor_writes(VkWriteDescriptorSet* descriptorWrite,
	VkDescriptorBufferInfo* bufferInfo,
	const GrVkUniformBuffer* buffer,
	VkDescriptorSet descriptorSet,
	uint32_t binding) {

	memset(bufferInfo, 0, sizeof(VkDescriptorBufferInfo));
	bufferInfo->buffer = buffer->buffer();
	bufferInfo->offset = buffer->offset();
	bufferInfo->range = buffer->size();

	memset(descriptorWrite, 0, sizeof(VkWriteDescriptorSet));
	descriptorWrite->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
	descriptorWrite->pNext = nullptr;
	descriptorWrite->dstSet = descriptorSet;
	descriptorWrite->dstBinding = binding;
	descriptorWrite->dstArrayElement = 0;
	descriptorWrite->descriptorCount = 1;
	descriptorWrite->descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
	descriptorWrite->pImageInfo = nullptr;
	descriptorWrite->pBufferInfo = bufferInfo;
	descriptorWrite->pTexelBufferView = nullptr;
	}

	void GrVkPipelineState::writeUniformBuffers(const GrVkGpu* gpu) {
	VkWriteDescriptorSet descriptorWrites[3];
	VkDescriptorBufferInfo bufferInfos[3];

	uint32_t writeCount = 0;

	// Geometry Uniform Buffer
	if (fGeometryUniformBuffer.get()) {
	set_uniform_descriptor_writes(&descriptorWrites[writeCount],
	&bufferInfos[writeCount],
	fGeometryUniformBuffer.get(),
	fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet],
	GrVkUniformHandler::kGeometryBinding);
	++writeCount;
	}

	// Fragment Uniform Buffer
	if (fFragmentUniformBuffer.get()) {
	set_uniform_descriptor_writes(&descriptorWrites[writeCount],
	&bufferInfos[writeCount],
	fFragmentUniformBuffer.get(),
	fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet],
	GrVkUniformHandler::kFragBinding);
	++writeCount;
	}

	if (writeCount) {
	GR_VK_CALL(gpu->vkInterface(), UpdateDescriptorSets(gpu->device(),
	writeCount,
	descriptorWrites,
	0, nullptr));
	}
	}

	void GrVkPipelineState::setRenderTargetState(const GrRenderTarget* rt, GrSurfaceOrigin origin) {

	// Load the RT height uniform if it is needed to y-flip gl_FragCoord.
	if (fBuiltinUniformHandles.fRTHeightUni.isValid() &&
	fRenderTargetState.fRenderTargetSize.fHeight != rt->height()) {
	fDataManager.set1f(fBuiltinUniformHandles.fRTHeightUni, SkIntToScalar(rt->height()));
	}

	// set RT adjustment
	SkISize size;
	size.set(rt->width(), rt->height());
	SkASSERT(fBuiltinUniformHandles.fRTAdjustmentUni.isValid());
	if (fRenderTargetState.fRenderTargetOrigin != origin \|\|
	fRenderTargetState.fRenderTargetSize != size) {
	fRenderTargetState.fRenderTargetSize = size;
	fRenderTargetState.fRenderTargetOrigin = origin;

	float rtAdjustmentVec[4];
	fRenderTargetState.getRTAdjustmentVec(rtAdjustmentVec);
	fDataManager.set4fv(fBuiltinUniformHandles.fRTAdjustmentUni, 1, rtAdjustmentVec);
	}
	}

	void GrVkPipelineState::bindPipeline(const GrVkGpu* gpu, GrVkCommandBuffer* commandBuffer) {
	commandBuffer->bindPipeline(gpu, fPipeline);
	}