GrVkPipeline Class Reference

#include <GrVkPipeline.h>

Inheritance diagram for GrVkPipeline:

Public Member Functions
VkPipeline	pipeline () const
VkPipelineLayout	layout () const
Public Member Functions inherited from GrVkManagedResource
	GrVkManagedResource (const GrVkGpu *gpu)
Public Member Functions inherited from GrManagedResource
	GrManagedResource ()
virtual	~GrManagedResource ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< GrVkPipeline >	Make (GrVkGpu *, const GrGeometryProcessor::AttributeSet &vertexAttribs, const GrGeometryProcessor::AttributeSet &instanceAttribs, GrPrimitiveType, GrSurfaceOrigin, const GrStencilSettings &, int numSamples, bool isHWAntialiasState, const skgpu::BlendInfo &, bool isWireframe, bool useConservativeRaster, uint32_t subpass, VkPipelineShaderStageCreateInfo *shaderStageInfo, int shaderStageCount, VkRenderPass compatibleRenderPass, VkPipelineLayout layout, bool ownsLayout, VkPipelineCache cache)
static sk_sp< GrVkPipeline >	Make (GrVkGpu *, const GrProgramInfo &, VkPipelineShaderStageCreateInfo *shaderStageInfo, int shaderStageCount, VkRenderPass compatibleRenderPass, VkPipelineLayout layout, VkPipelineCache cache, uint32_t subpass)
static void	SetDynamicScissorRectState (GrVkGpu *, GrVkCommandBuffer *, SkISize colorAttachmentDimensions, GrSurfaceOrigin, const SkIRect &scissorRect)
static void	SetDynamicViewportState (GrVkGpu *, GrVkCommandBuffer *, SkISize colorAttachmentDimensions)
static void	SetDynamicBlendConstantState (GrVkGpu *, GrVkCommandBuffer *, const skgpu::Swizzle &writeSwizzle, const GrXferProcessor &)

Protected Member Functions
	GrVkPipeline (const GrVkGpu *gpu, VkPipeline pipeline, VkPipelineLayout layout)

Protected Attributes
VkPipeline	fPipeline
VkPipelineLayout	fPipelineLayout
Protected Attributes inherited from GrVkManagedResource
const GrVkGpu *	fGpu

Private Member Functions
void	freeGPUData () const override

Detailed Description

Definition at line 33 of file GrVkPipeline.h.

Constructor & Destructor Documentation

GrVkPipeline()

GrVkPipeline::GrVkPipeline ( const GrVkGpu *  gpu, VkPipeline  pipeline, VkPipelineLayout  layout  )

inlineprotected

Definition at line 88 of file GrVkPipeline.h.

            : INHERITED(gpu), fPipeline(pipeline), fPipelineLayout(layout) {}

Member Function Documentation

freeGPUData()

void GrVkPipeline::freeGPUData ( ) const

overrideprivatevirtual

Must be implemented by any subclasses. Deletes any GPU data associated with this resource

Implements GrManagedResource.

Definition at line 600 of file GrVkPipeline.cpp.

                                     {
    GR_VK_CALL(fGpu->vkInterface(), DestroyPipeline(fGpu->device(), fPipeline, nullptr));
    if (fPipelineLayout != VK_NULL_HANDLE) {
        GR_VK_CALL(fGpu->vkInterface(),
                   DestroyPipelineLayout(fGpu->device(), fPipelineLayout, nullptr));
    }
}

layout()

VkPipelineLayout GrVkPipeline::layout ( ) const

inline

Definition at line 64 of file GrVkPipeline.h.

                                    {
        SkASSERT(fPipelineLayout != VK_NULL_HANDLE);
        return fPipelineLayout;
    }

Make() [1/2]

sk_sp< GrVkPipeline > GrVkPipeline::Make ( GrVkGpu *  gpu, const GrGeometryProcessor::AttributeSet &  vertexAttribs, const GrGeometryProcessor::AttributeSet &  instanceAttribs, GrPrimitiveType  primitiveType, GrSurfaceOrigin  origin, const GrStencilSettings &  stencilSettings, int  numSamples, bool  isHWAntialiasState, const skgpu::BlendInfo &  blendInfo, bool  isWireframe, bool  useConservativeRaster, uint32_t  subpass, VkPipelineShaderStageCreateInfo *  shaderStageInfo, int  shaderStageCount, VkRenderPass  compatibleRenderPass, VkPipelineLayout  layout, bool  ownsLayout, VkPipelineCache  cache  )

static

Definition at line 465 of file GrVkPipeline.cpp.

                                                          {
    VkPipelineVertexInputStateCreateInfo vertexInputInfo;
    STArray<2, VkVertexInputBindingDescription, true> bindingDescs;
    STArray<16, VkVertexInputAttributeDescription> attributeDesc;
    int totalAttributeCnt = vertexAttribs.count() + instanceAttribs.count();
    SkASSERT(totalAttributeCnt <= gpu->vkCaps().maxVertexAttributes());
    VkVertexInputAttributeDescription* pAttribs = attributeDesc.push_back_n(totalAttributeCnt);
    setup_vertex_input_state(vertexAttribs, instanceAttribs, &vertexInputInfo, &bindingDescs,
                             pAttribs);
 
    VkPipelineInputAssemblyStateCreateInfo inputAssemblyInfo;
    setup_input_assembly_state(primitiveType, &inputAssemblyInfo);
 
    VkPipelineDepthStencilStateCreateInfo depthStencilInfo;
    setup_depth_stencil_state(stencilSettings, origin, &depthStencilInfo);
 
    VkPipelineViewportStateCreateInfo viewportInfo;
    setup_viewport_scissor_state(&viewportInfo);
 
    VkPipelineMultisampleStateCreateInfo multisampleInfo;
    setup_multisample_state(numSamples, gpu->caps(), &multisampleInfo);
 
    // We will only have one color attachment per pipeline.
    VkPipelineColorBlendAttachmentState attachmentStates[1];
    VkPipelineColorBlendStateCreateInfo colorBlendInfo;
    setup_color_blend_state(blendInfo, &colorBlendInfo, attachmentStates);
 
    VkPipelineRasterizationStateCreateInfo rasterInfo;
    setup_raster_state(isWireframe, gpu->caps(), &rasterInfo);
 
    VkPipelineRasterizationConservativeStateCreateInfoEXT conservativeRasterInfo;
    if (useConservativeRaster) {
        SkASSERT(gpu->caps()->conservativeRasterSupport());
        setup_conservative_raster_info(&conservativeRasterInfo);
        conservativeRasterInfo.pNext = rasterInfo.pNext;
        rasterInfo.pNext = &conservativeRasterInfo;
    }
 
    VkDynamicState dynamicStates[3];
    VkPipelineDynamicStateCreateInfo dynamicInfo;
    setup_dynamic_state(&dynamicInfo, dynamicStates);
 
    VkGraphicsPipelineCreateInfo pipelineCreateInfo;
    memset(&pipelineCreateInfo, 0, sizeof(VkGraphicsPipelineCreateInfo));
    pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
    pipelineCreateInfo.pNext = nullptr;
    pipelineCreateInfo.flags = 0;
    pipelineCreateInfo.stageCount = shaderStageCount;
    pipelineCreateInfo.pStages = shaderStageInfo;
    pipelineCreateInfo.pVertexInputState = &vertexInputInfo;
    pipelineCreateInfo.pInputAssemblyState = &inputAssemblyInfo;
    pipelineCreateInfo.pTessellationState = nullptr;
    pipelineCreateInfo.pViewportState = &viewportInfo;
    pipelineCreateInfo.pRasterizationState = &rasterInfo;
    pipelineCreateInfo.pMultisampleState = &multisampleInfo;
    pipelineCreateInfo.pDepthStencilState = &depthStencilInfo;
    pipelineCreateInfo.pColorBlendState = &colorBlendInfo;
    pipelineCreateInfo.pDynamicState = &dynamicInfo;
    pipelineCreateInfo.layout = layout;
    pipelineCreateInfo.renderPass = compatibleRenderPass;
    pipelineCreateInfo.subpass = subpass;
    pipelineCreateInfo.basePipelineHandle = VK_NULL_HANDLE;
    pipelineCreateInfo.basePipelineIndex = -1;
 
    VkPipeline vkPipeline;
    VkResult err;
    {
        TRACE_EVENT0_ALWAYS("skia.shaders", "CreateGraphicsPipeline");
#if defined(SK_ENABLE_SCOPED_LSAN_SUPPRESSIONS)
        // skia:8712
        __lsan::ScopedDisabler lsanDisabler;
#endif
        GR_VK_CALL_RESULT(gpu, err, CreateGraphicsPipelines(gpu->device(), cache, 1,
                                                            &pipelineCreateInfo, nullptr,
                                                            &vkPipeline));
    }
    if (err) {
        SkDebugf("Failed to create pipeline. Error: %d\n", err);
        return nullptr;
    }
 
    if (!ownsLayout) {
        layout = VK_NULL_HANDLE;
    }
    return sk_sp<GrVkPipeline>(new GrVkPipeline(gpu, vkPipeline, layout));
}

Make() [2/2]

sk_sp< GrVkPipeline > GrVkPipeline::Make ( GrVkGpu *  gpu, const GrProgramInfo &  programInfo, VkPipelineShaderStageCreateInfo *  shaderStageInfo, int  shaderStageCount, VkRenderPass  compatibleRenderPass, VkPipelineLayout  layout, VkPipelineCache  cache, uint32_t  subpass  )

static

Definition at line 569 of file GrVkPipeline.cpp.

                                                         {
    const GrGeometryProcessor& geomProc = programInfo.geomProc();
    const GrPipeline& pipeline = programInfo.pipeline();
 
    return Make(gpu,
                geomProc.vertexAttributes(),
                geomProc.instanceAttributes(),
                programInfo.primitiveType(),
                programInfo.origin(),
                programInfo.nonGLStencilSettings(),
                programInfo.numSamples(),
                programInfo.numSamples() > 1,
                pipeline.getXferProcessor().getBlendInfo(),
                pipeline.isWireframe(),
                pipeline.usesConservativeRaster(),
                subpass,
                shaderStageInfo,
                shaderStageCount,
                compatibleRenderPass,
                layout,
                /*ownsLayout=*/true,
                cache);
}

pipeline()

VkPipeline GrVkPipeline::pipeline ( ) const

inline

Definition at line 63 of file GrVkPipeline.h.

{ return fPipeline; }

SetDynamicBlendConstantState()

void GrVkPipeline::SetDynamicBlendConstantState ( GrVkGpu *  gpu, GrVkCommandBuffer *  cmdBuffer, const skgpu::Swizzle &  writeSwizzle, const GrXferProcessor &  xferProcessor  )

static

Definition at line 646 of file GrVkPipeline.cpp.

                                                                                      {
    const skgpu::BlendInfo& blendInfo = xferProcessor.getBlendInfo();
    skgpu::BlendCoeff srcCoeff = blendInfo.fSrcBlend;
    skgpu::BlendCoeff dstCoeff = blendInfo.fDstBlend;
    float floatColors[4];
    if (skgpu::BlendCoeffRefsConstant(srcCoeff) || skgpu::BlendCoeffRefsConstant(dstCoeff)) {
        // Swizzle the blend to match what the shader will output.
        SkPMColor4f blendConst = swizzle.applyTo(blendInfo.fBlendConstant);
        floatColors[0] = blendConst.fR;
        floatColors[1] = blendConst.fG;
        floatColors[2] = blendConst.fB;
        floatColors[3] = blendConst.fA;
        cmdBuffer->setBlendConstants(gpu, floatColors);
    }
}

SetDynamicScissorRectState()

void GrVkPipeline::SetDynamicScissorRectState ( GrVkGpu *  gpu, GrVkCommandBuffer *  cmdBuffer, SkISize  colorAttachmentDimensions, GrSurfaceOrigin  rtOrigin, const SkIRect &  scissorRect  )

static

Definition at line 608 of file GrVkPipeline.cpp.

                                                                          {
    SkASSERT(scissorRect.isEmpty() ||
             SkIRect::MakeSize(colorAttachmentDimensions).contains(scissorRect));
 
    VkRect2D scissor;
    scissor.offset.x = scissorRect.fLeft;
    scissor.extent.width = scissorRect.width();
    if (kTopLeft_GrSurfaceOrigin == rtOrigin) {
        scissor.offset.y = scissorRect.fTop;
    } else {
        SkASSERT(kBottomLeft_GrSurfaceOrigin == rtOrigin);
        scissor.offset.y = colorAttachmentDimensions.height() - scissorRect.fBottom;
    }
    scissor.extent.height = scissorRect.height();
 
    SkASSERT(scissor.offset.x >= 0);
    SkASSERT(scissor.offset.y >= 0);
    cmdBuffer->setScissor(gpu, 0, 1, &scissor);
}

SetDynamicViewportState()

void GrVkPipeline::SetDynamicViewportState ( GrVkGpu *  gpu, GrVkCommandBuffer *  cmdBuffer, SkISize  colorAttachmentDimensions  )

static

Definition at line 632 of file GrVkPipeline.cpp.

                                                                              {
    // We always use one viewport the size of the RT
    VkViewport viewport;
    viewport.x = 0.0f;
    viewport.y = 0.0f;
    viewport.width = SkIntToScalar(colorAttachmentDimensions.width());
    viewport.height = SkIntToScalar(colorAttachmentDimensions.height());
    viewport.minDepth = 0.0f;
    viewport.maxDepth = 1.0f;
    cmdBuffer->setViewport(gpu, 0, 1, &viewport);
}

Member Data Documentation

fPipeline

VkPipeline GrVkPipeline::fPipeline

protected

Definition at line 91 of file GrVkPipeline.h.

fPipelineLayout

VkPipelineLayout GrVkPipeline::fPipelineLayout

protected

Definition at line 92 of file GrVkPipeline.h.

---

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

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