GrVkPipelineState Class Reference

#include <GrVkPipelineState.h>

Public Types
using	UniformInfoArray = GrVkPipelineStateDataManager::UniformInfoArray
using	UniformHandle = GrGLSLProgramDataManager::UniformHandle

Public Member Functions
	GrVkPipelineState (GrVkGpu *, sk_sp< const GrVkPipeline >, const GrVkDescriptorSetManager::Handle &samplerDSHandle, const GrGLSLBuiltinUniformHandles &builtinUniformHandles, const UniformInfoArray &uniforms, uint32_t uniformSize, bool usePushConstants, const UniformInfoArray &samplers, std::unique_ptr< GrGeometryProcessor::ProgramImpl >, std::unique_ptr< GrXferProcessor::ProgramImpl >, std::vector< std::unique_ptr< GrFragmentProcessor::ProgramImpl > > fpImpls)
	~GrVkPipelineState ()
bool	setAndBindUniforms (GrVkGpu *, SkISize colorAttachmentDimensions, const GrProgramInfo &, GrVkCommandBuffer *)
bool	setAndBindTextures (GrVkGpu *, const GrGeometryProcessor &, const GrPipeline &, const GrSurfaceProxy *const geomProcTextures[], GrVkCommandBuffer *)
bool	setAndBindInputAttachment (GrVkGpu *, gr_rp< const GrVkDescriptorSet > inputDescSet, GrVkCommandBuffer *)
void	bindPipeline (const GrVkGpu *gpu, GrVkCommandBuffer *commandBuffer)
void	freeGPUResources (GrVkGpu *gpu)

Detailed Description

This class holds onto a GrVkPipeline object that we use for draws. Besides storing the acutal GrVkPipeline object, this class is also responsible handling all uniforms, descriptors, samplers, and other similar objects that are used along with the VkPipeline in the draw. This includes both allocating and freeing these objects, as well as updating their values.

Definition at line 37 of file GrVkPipelineState.h.

Member Typedef Documentation

UniformHandle

using GrVkPipelineState::UniformHandle = GrGLSLProgramDataManager::UniformHandle

Definition at line 40 of file GrVkPipelineState.h.

UniformInfoArray

using GrVkPipelineState::UniformInfoArray = GrVkPipelineStateDataManager::UniformInfoArray

Definition at line 39 of file GrVkPipelineState.h.

Constructor & Destructor Documentation

GrVkPipelineState()

GrVkPipelineState::GrVkPipelineState	(	GrVkGpu *	gpu,
		sk_sp< const GrVkPipeline >	pipeline,
		const GrVkDescriptorSetManager::Handle &	samplerDSHandle,
		const GrGLSLBuiltinUniformHandles &	builtinUniformHandles,
		const UniformInfoArray &	uniforms,
		uint32_t	uniformSize,
		bool	usePushConstants,
		const UniformInfoArray &	samplers,
		std::unique_ptr< GrGeometryProcessor::ProgramImpl >	gpImpl,
		std::unique_ptr< GrXferProcessor::ProgramImpl >	xpImpl,
		std::vector< std::unique_ptr< GrFragmentProcessor::ProgramImpl > >	fpImpls
	)

Definition at line 31 of file GrVkPipelineState.cpp.

        : fPipeline(std::move(pipeline))
        , fSamplerDSHandle(samplerDSHandle)
        , fBuiltinUniformHandles(builtinUniformHandles)
        , fGPImpl(std::move(gpImpl))
        , fXPImpl(std::move(xpImpl))
        , fFPImpls(std::move(fpImpls))
        , fDataManager(uniforms, uniformSize, usePushConstants) {
    fNumSamplers = samplers.count();
    for (const auto& sampler : samplers.items()) {
        // We store the immutable samplers here and take a ref on the sampler. Once we switch to
        // using sk_sps here we should just move the immutable samplers to save the extra ref/unref.
        if (sampler.fImmutableSampler) {
            sampler.fImmutableSampler->ref();
        }
        fImmutableSamplers.push_back(sampler.fImmutableSampler);
    }
}

~GrVkPipelineState()

GrVkPipelineState::~GrVkPipelineState

(

)

Definition at line 61 of file GrVkPipelineState.cpp.

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

Member Function Documentation

bindPipeline()

void GrVkPipelineState::bindPipeline	(	const GrVkGpu *	gpu,
		GrVkCommandBuffer *	commandBuffer
	)

Definition at line 274 of file GrVkPipelineState.cpp.

                                                                                         {
    commandBuffer->bindPipeline(gpu, fPipeline);
}

freeGPUResources()

void GrVkPipelineState::freeGPUResources

(

GrVkGpu *

gpu

)

Definition at line 66 of file GrVkPipelineState.cpp.

                                                     {
    fPipeline.reset();
    fDataManager.releaseData();
    for (int i = 0; i < fImmutableSamplers.size(); ++i) {
        if (fImmutableSamplers[i]) {
            fImmutableSamplers[i]->unref();
            fImmutableSamplers[i] = nullptr;
        }
    }
}

setAndBindInputAttachment()

bool GrVkPipelineState::setAndBindInputAttachment	(	GrVkGpu *	gpu,
		gr_rp< const GrVkDescriptorSet >	inputDescSet,
		GrVkCommandBuffer *	commandBuffer
	)

Definition at line 237 of file GrVkPipelineState.cpp.

                                                                                    {
    SkASSERT(inputDescSet);
    commandBuffer->bindDescriptorSets(gpu, fPipeline->layout(), GrVkUniformHandler::kInputDescSet,
                                      /*setCount=*/1, inputDescSet->descriptorSet(),
                                      /*dynamicOffsetCount=*/0, /*dynamicOffsets=*/nullptr);
    // We don't add the input resource to the command buffer to track since the input will be
    // the same as the color attachment which is already tracked on the command buffer.
    commandBuffer->addRecycledResource(std::move(inputDescSet));
    return true;
}

setAndBindTextures()

bool GrVkPipelineState::setAndBindTextures	(	GrVkGpu *	gpu,
		const GrGeometryProcessor &	geomProc,
		const GrPipeline &	pipeline,
		const GrSurfaceProxy *const	geomProcTextures[],
		GrVkCommandBuffer *	commandBuffer
	)

This must be called after setAndBindUniforms() since that function invalidates texture bindings.

Definition at line 113 of file GrVkPipelineState.cpp.

                                                                             {
    SkASSERT(geomProcTextures || !geomProc.numTextureSamplers());
    if (!fNumSamplers) {
        return true;
    }
    struct SamplerBindings {
        GrSamplerState fState;
        GrVkTexture* fTexture;
    };
    AutoSTArray<8, SamplerBindings> samplerBindings(fNumSamplers);
    int currTextureBinding = 0;
 
    for (int i = 0; i < geomProc.numTextureSamplers(); ++i) {
        SkASSERT(geomProcTextures[i]->asTextureProxy());
        const auto& sampler = geomProc.textureSampler(i);
        auto texture = static_cast<GrVkTexture*>(geomProcTextures[i]->peekTexture());
        samplerBindings[currTextureBinding++] = {sampler.samplerState(), texture};
    }
 
 
    if (GrTexture* dstTexture = pipeline.peekDstTexture()) {
        samplerBindings[currTextureBinding++] = {GrSamplerState::Filter::kNearest,
                                                 static_cast<GrVkTexture*>(dstTexture)};
    }
 
    pipeline.visitTextureEffects([&](const GrTextureEffect& te) {
        GrSamplerState samplerState = te.samplerState();
        auto* texture = static_cast<GrVkTexture*>(te.texture());
        samplerBindings[currTextureBinding++] = {samplerState, texture};
    });
 
    // Get new descriptor set
    SkASSERT(fNumSamplers == currTextureBinding);
    static const int kSamplerDSIdx = GrVkUniformHandler::kSamplerDescSet;
 
    if (fNumSamplers == 1) {
        auto texture = samplerBindings[0].fTexture;
        auto texAttachment = texture->textureImage();
        const auto& samplerState = samplerBindings[0].fState;
        const GrVkDescriptorSet* descriptorSet = texture->cachedSingleDescSet(samplerState);
        if (descriptorSet) {
            commandBuffer->addGrSurface(sk_ref_sp<const GrSurface>(texture));
            commandBuffer->addResource(texAttachment->textureView());
            commandBuffer->addResource(texAttachment->resource());
            commandBuffer->addRecycledResource(descriptorSet);
            commandBuffer->bindDescriptorSets(gpu, fPipeline->layout(), kSamplerDSIdx,
                                              /*setCount=*/1, descriptorSet->descriptorSet(),
                                              /*dynamicOffsetCount=*/0,
                                              /*dynamicOffsets=*/nullptr);
            return true;
        }
    }
 
    const GrVkDescriptorSet* descriptorSet =
            gpu->resourceProvider().getSamplerDescriptorSet(fSamplerDSHandle);
    if (!descriptorSet) {
        return false;
    }
 
    for (int i = 0; i < fNumSamplers; ++i) {
        GrSamplerState state = samplerBindings[i].fState;
        GrVkTexture* texture = samplerBindings[i].fTexture;
        auto texAttachment = texture->textureImage();
 
        const GrVkImageView* textureView = texAttachment->textureView();
        const GrVkSampler* sampler = nullptr;
        if (fImmutableSamplers[i]) {
            sampler = fImmutableSamplers[i];
        } else {
            sampler = gpu->resourceProvider().findOrCreateCompatibleSampler(
                    state, texAttachment->ycbcrConversionInfo());
            if (!sampler) {
                descriptorSet->recycle();
                return false;
            }
        }
        SkASSERT(sampler);
 
        VkDescriptorImageInfo imageInfo;
        memset(&imageInfo, 0, sizeof(VkDescriptorImageInfo));
        imageInfo.sampler = fImmutableSamplers[i] ? VK_NULL_HANDLE : 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 = *descriptorSet->descriptorSet();
        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();
        }
        commandBuffer->addResource(textureView);
        commandBuffer->addResource(texAttachment->resource());
    }
    if (fNumSamplers == 1) {
        GrSamplerState state = samplerBindings[0].fState;
        GrVkTexture* texture = samplerBindings[0].fTexture;
        texture->addDescriptorSetToCache(descriptorSet, state);
    }
 
    commandBuffer->bindDescriptorSets(gpu, fPipeline->layout(), kSamplerDSIdx, /*setCount=*/1,
                                      descriptorSet->descriptorSet(),
                                      /*dynamicOffsetCount=*/0, /*dynamicOffsets=*/nullptr);
    commandBuffer->addRecycledResource(descriptorSet);
    descriptorSet->recycle();
    return true;
}

setAndBindUniforms()

bool GrVkPipelineState::setAndBindUniforms	(	GrVkGpu *	gpu,
		SkISize	colorAttachmentDimensions,
		const GrProgramInfo &	programInfo,
		GrVkCommandBuffer *	commandBuffer
	)

Definition at line 77 of file GrVkPipelineState.cpp.

                                                                             {
    this->setRenderTargetState(colorAttachmentDimensions, programInfo.origin());
 
    fGPImpl->setData(fDataManager, *gpu->caps()->shaderCaps(), programInfo.geomProc());
 
    for (int i = 0; i < programInfo.pipeline().numFragmentProcessors(); ++i) {
        const auto& fp = programInfo.pipeline().getFragmentProcessor(i);
        fp.visitWithImpls([&](const GrFragmentProcessor& fp,
                              GrFragmentProcessor::ProgramImpl& impl) {
            impl.setData(fDataManager, fp);
        }, *fFPImpls[i]);
    }
 
    programInfo.pipeline().setDstTextureUniforms(fDataManager, &fBuiltinUniformHandles);
    fXPImpl->setData(fDataManager, programInfo.pipeline().getXferProcessor());
 
    // Upload uniform data and bind descriptor set.
    auto [uniformBuffer, success] = fDataManager.uploadUniforms(gpu, fPipeline->layout(),
                                                                commandBuffer);
    if (!success) {
        return false;
    }
    if (uniformBuffer) {
        const GrVkBuffer* vkBuffer = static_cast<GrVkBuffer*>(uniformBuffer.get());
        static const int kUniformDSIdx = GrVkUniformHandler::kUniformBufferDescSet;
        commandBuffer->bindDescriptorSets(gpu, fPipeline->layout(), kUniformDSIdx, /*setCount=*/1,
                                          vkBuffer->uniformDescriptorSet(),
                                          /*dynamicOffsetCount=*/0, /*dynamicOffsets=*/nullptr);
        commandBuffer->addGrBuffer(std::move(uniformBuffer));
    }
    return true;
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/ganesh/vk/GrVkPipelineState.h
• third_party/skia/src/gpu/ganesh/vk/GrVkPipelineState.cpp