#include <GrVkOpsRenderPass.h>

Inheritance diagram for GrVkOpsRenderPass:

Public Member Functions
	GrVkOpsRenderPass (GrVkGpu *)

	~GrVkOpsRenderPass () override

void	inlineUpload (GrOpFlushState *state, GrDeferredTextureUploadFn &upload) override

void	onExecuteDrawable (std::unique_ptr< SkDrawable::GpuDrawHandler >) override

bool	set (GrRenderTarget , sk_sp< GrVkFramebuffer >, GrSurfaceOrigin, const SkIRect &bounds, const GrOpsRenderPass::LoadAndStoreInfo &, const GrOpsRenderPass::StencilLoadAndStoreInfo &, const GrOpsRenderPass::LoadAndStoreInfo &resolveInfo, GrVkRenderPass::SelfDependencyFlags selfDepFlags, GrVkRenderPass::LoadFromResolve loadFromResolve, const skia_private::TArray< GrSurfaceProxy , true > &sampledProxies)

void	reset ()

void	submit ()

Public Member Functions inherited from GrOpsRenderPass
virtual	~GrOpsRenderPass ()

void	begin ()

void	end ()

void	bindPipeline (const GrProgramInfo &, const SkRect &drawBounds)

void	setScissorRect (const SkIRect &)

void	bindTextures (const GrGeometryProcessor &, const GrSurfaceProxy *const geomProcTextures[], const GrPipeline &)

void	bindBuffers (sk_sp< const GrBuffer > indexBuffer, sk_sp< const GrBuffer > instanceBuffer, sk_sp< const GrBuffer > vertexBuffer, GrPrimitiveRestart=GrPrimitiveRestart::kNo)

void	draw (int vertexCount, int baseVertex)

void	drawIndexed (int indexCount, int baseIndex, uint16_t minIndexValue, uint16_t maxIndexValue, int baseVertex)

void	drawInstanced (int instanceCount, int baseInstance, int vertexCount, int baseVertex)

void	drawIndexedInstanced (int indexCount, int baseIndex, int instanceCount, int baseInstance, int baseVertex)

void	drawIndirect (const GrBuffer *drawIndirectBuffer, size_t bufferOffset, int drawCount)

void	drawIndexedIndirect (const GrBuffer *drawIndirectBuffer, size_t bufferOffset, int drawCount)

void	drawIndexPattern (int patternIndexCount, int patternRepeatCount, int maxPatternRepetitionsInIndexBuffer, int patternVertexCount, int baseVertex)

void	clear (const GrScissorState &scissor, std::array< float, 4 > color)

void	clearStencilClip (const GrScissorState &scissor, bool insideStencilMask)

void	executeDrawable (std::unique_ptr< SkDrawable::GpuDrawHandler >)

Private Member Functions
GrGpu *	gpu () override

void	onEnd () override

bool	onBindPipeline (const GrProgramInfo &, const SkRect &drawBounds) override

void	onSetScissorRect (const SkIRect &) override

bool	onBindTextures (const GrGeometryProcessor &, const GrSurfaceProxy *const geomProcTextures[], const GrPipeline &) override

void	onBindBuffers (sk_sp< const GrBuffer > indexBuffer, sk_sp< const GrBuffer > instanceBuffer, sk_sp< const GrBuffer > vertexBuffer, GrPrimitiveRestart) override

void	onDraw (int vertexCount, int baseVertex) override

void	onDrawIndexed (int indexCount, int baseIndex, uint16_t minIndexValue, uint16_t maxIndexValue, int baseVertex) override

void	onDrawInstanced (int instanceCount, int baseInstance, int vertexCount, int baseVertex) override

void	onDrawIndexedInstanced (int indexCount, int baseIndex, int instanceCount, int baseInstance, int baseVertex) override

void	onDrawIndirect (const GrBuffer *drawIndirectBuffer, size_t offset, int drawCount) override

void	onDrawIndexedIndirect (const GrBuffer *drawIndirectBuffer, size_t offset, int drawCount) override

void	onClear (const GrScissorState &scissor, std::array< float, 4 > color) override

void	onClearStencilClip (const GrScissorState &scissor, bool insideStencilMask) override

Additional Inherited Members
Protected Member Functions inherited from GrOpsRenderPass
	GrOpsRenderPass ()

	GrOpsRenderPass (GrRenderTarget *rt, GrSurfaceOrigin origin)

void	set (GrRenderTarget *rt, GrSurfaceOrigin origin)

Protected Attributes inherited from GrOpsRenderPass
GrSurfaceOrigin	fOrigin

GrRenderTarget *	fRenderTarget

sk_sp< const GrBuffer >	fActiveIndexBuffer

sk_sp< const GrBuffer >	fActiveVertexBuffer

sk_sp< const GrBuffer >	fActiveInstanceBuffer

Detailed Description

Definition at line 25 of file GrVkOpsRenderPass.h.

Constructor & Destructor Documentation

◆ GrVkOpsRenderPass()

GrVkOpsRenderPass::GrVkOpsRenderPass ( GrVkGpu * gpu )

Definition at line 67 of file GrVkOpsRenderPass.cpp.

67: fGpu(gpu) {}

GrVkOpsRenderPass::gpu

GrGpu * gpu() override

Definition GrVkOpsRenderPass.cpp:292

◆ ~GrVkOpsRenderPass()

GrVkOpsRenderPass::~GrVkOpsRenderPass ( )

override

Definition at line 288 of file GrVkOpsRenderPass.cpp.

                                      {
    this->reset();
}

Member Function Documentation

◆ gpu()

GrGpu * GrVkOpsRenderPass::gpu ( )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 292 of file GrVkOpsRenderPass.cpp.

292{ return fGpu; }

◆ inlineUpload()

void GrVkOpsRenderPass::inlineUpload	(	GrOpFlushState *	state,
		GrDeferredTextureUploadFn &	upload
	)

overridevirtual

Implements GrOpsRenderPass.

Definition at line 600 of file GrVkOpsRenderPass.cpp.

                                                                                             {
    if (!fCurrentRenderPass) {
        SkASSERT(fGpu->isDeviceLost());
        return;
    }
    if (fCurrentSecondaryCommandBuffer) {
        fCurrentSecondaryCommandBuffer->end(fGpu);
        fGpu->submitSecondaryCommandBuffer(std::move(fCurrentSecondaryCommandBuffer));
    }
    fGpu->endRenderPass(fRenderTarget, fOrigin, fBounds);
 
    // We pass in true here to signal that after the upload we need to set the upload textures
    // layout back to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL.
    state->doUpload(upload, true);
 
    this->addAdditionalRenderPass(false);
}

◆ onBindBuffers()

void GrVkOpsRenderPass::onBindBuffers	(	sk_sp< const GrBuffer >	indexBuffer,
		sk_sp< const GrBuffer >	instanceBuffer,
		sk_sp< const GrBuffer >	vertexBuffer,
		GrPrimitiveRestart	primRestart
	)

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 725 of file GrVkOpsRenderPass.cpp.

                                                                      {
    SkASSERT(GrPrimitiveRestart::kNo == primRestart);
    if (!fCurrentRenderPass) {
        SkASSERT(fGpu->isDeviceLost());
        return;
    }
    SkASSERT(fCurrentPipelineState);
    SkASSERT(!fGpu->caps()->usePrimitiveRestart());  // Ignore primitiveRestart parameter.
 
    GrVkCommandBuffer* currCmdBuf = this->currentCommandBuffer();
    SkASSERT(currCmdBuf);
 
    // There is no need to put any memory barriers to make sure host writes have finished here.
    // When a command buffer is submitted to a queue, there is an implicit memory barrier that
    // occurs for all host writes. Additionally, BufferMemoryBarriers are not allowed inside of
    // an active RenderPass.
 
    // Here our vertex and instance inputs need to match the same 0-based bindings they were
    // assigned in GrVkPipeline. That is, vertex first (if any) followed by instance.
    uint32_t binding = 0;
    if (vertexBuffer) {
        SkDEBUGCODE(auto* gpuVertexBuffer = static_cast<const GrGpuBuffer*>(vertexBuffer.get()));
        SkASSERT(!gpuVertexBuffer->isCpuBuffer());
        SkASSERT(!gpuVertexBuffer->isMapped());
        currCmdBuf->bindInputBuffer(fGpu, binding++, std::move(vertexBuffer));
    }
    if (instanceBuffer) {
        SkDEBUGCODE(auto* gpuInstanceBuffer =
                            static_cast<const GrGpuBuffer*>(instanceBuffer.get()));
        SkASSERT(!gpuInstanceBuffer->isCpuBuffer());
        SkASSERT(!gpuInstanceBuffer->isMapped());
        currCmdBuf->bindInputBuffer(fGpu, binding++, std::move(instanceBuffer));
    }
    if (indexBuffer) {
        SkDEBUGCODE(auto* gpuIndexBuffer = static_cast<const GrGpuBuffer*>(indexBuffer.get()));
        SkASSERT(!gpuIndexBuffer->isCpuBuffer());
        SkASSERT(!gpuIndexBuffer->isMapped());
        currCmdBuf->bindIndexBuffer(fGpu, std::move(indexBuffer));
    }
}

◆ onBindPipeline()

bool GrVkOpsRenderPass::onBindPipeline	(	const GrProgramInfo &	programInfo,
		const SkRect &	drawBounds
	)

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 626 of file GrVkOpsRenderPass.cpp.

                                                                                                 {
    if (!fCurrentRenderPass) {
        SkASSERT(fGpu->isDeviceLost());
        return false;
    }
 
    SkRect rtRect = SkRect::Make(fBounds);
    if (rtRect.intersect(drawBounds)) {
        rtRect.roundOut(&fCurrentPipelineBounds);
    } else {
        fCurrentPipelineBounds.setEmpty();
    }
 
    GrVkCommandBuffer* currentCB = this->currentCommandBuffer();
    SkASSERT(fCurrentRenderPass);
 
    VkRenderPass compatibleRenderPass = fCurrentRenderPass->vkRenderPass();
    fCurrentPipelineState = fGpu->resourceProvider().findOrCreateCompatiblePipelineState(
            fRenderTarget, programInfo, compatibleRenderPass, fOverridePipelinesForResolveLoad);
    if (!fCurrentPipelineState) {
        return false;
    }
 
    fCurrentPipelineState->bindPipeline(fGpu, currentCB);
 
    // Both the 'programInfo' and this renderPass have an origin. Since they come from the
    // same place (i.e., the target renderTargetProxy) they had best agree.
    SkASSERT(programInfo.origin() == fOrigin);
 
    auto colorAttachment = fFramebuffer->colorAttachment();
    if (!fCurrentPipelineState->setAndBindUniforms(fGpu, colorAttachment->dimensions(), programInfo,
                                                   currentCB)) {
        return false;
    }
 
    if (!programInfo.pipeline().isScissorTestEnabled()) {
        // "Disable" scissor by setting it to the full pipeline bounds.
        GrVkPipeline::SetDynamicScissorRectState(
                fGpu, currentCB, colorAttachment->dimensions(), fOrigin,
                                                 fCurrentPipelineBounds);
    }
    GrVkPipeline::SetDynamicViewportState(fGpu, currentCB, colorAttachment->dimensions());
    GrVkPipeline::SetDynamicBlendConstantState(fGpu, currentCB,
                                               programInfo.pipeline().writeSwizzle(),
                                               programInfo.pipeline().getXferProcessor());
 
    return true;
}

◆ onBindTextures()

bool GrVkOpsRenderPass::onBindTextures	(	const GrGeometryProcessor &	geomProc,
		const GrSurfaceProxy *const	geomProcTextures[],
		const GrPipeline &	pipeline
	)

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 693 of file GrVkOpsRenderPass.cpp.

                                                                   {
#ifdef SK_DEBUG
    SkASSERT(fCurrentPipelineState);
    auto colorAttachment = fFramebuffer->colorAttachment();
    for (int i = 0; i < geomProc.numTextureSamplers(); ++i) {
        check_sampled_texture(geomProcTextures[i]->peekTexture(), colorAttachment, fGpu);
    }
    pipeline.visitTextureEffects([&](const GrTextureEffect& te) {
        check_sampled_texture(te.texture(), colorAttachment, fGpu);
    });
    if (GrTexture* dstTexture = pipeline.peekDstTexture()) {
        check_sampled_texture(dstTexture, colorAttachment, fGpu);
    }
#endif
    if (!fCurrentPipelineState->setAndBindTextures(fGpu, geomProc, pipeline, geomProcTextures,
                                                   this->currentCommandBuffer())) {
        return false;
    }
    if (fSelfDependencyFlags == SelfDependencyFlags::kForInputAttachment) {
        // We bind the color attachment as an input attachment
        auto ds = fFramebuffer->colorAttachment()->inputDescSetForBlending(fGpu);
        if (!ds) {
            return false;
        }
        return fCurrentPipelineState->setAndBindInputAttachment(fGpu, std::move(ds),
                                                                this->currentCommandBuffer());
    }
    return true;
}

◆ onClear()

void GrVkOpsRenderPass::onClear	(	const GrScissorState &	scissor,
		std::array< float, 4 >	color
	)

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 485 of file GrVkOpsRenderPass.cpp.

                                                                                       {
    if (!fCurrentRenderPass) {
        SkASSERT(fGpu->isDeviceLost());
        return;
    }
 
    VkClearColorValue vkColor = {{color[0], color[1], color[2], color[3]}};
 
    // If we end up in a situation where we are calling clear without a scissior then in general it
    // means we missed an opportunity higher up the stack to set the load op to be a clear. However,
    // there are situations where higher up we couldn't discard the previous ops and set a clear
    // load op (e.g. if we needed to execute a wait op). Thus we also have the empty check here.
    // TODO: Make the waitOp a RenderTask instead so we can clear out the OpsTask for a clear. We
    // can then reenable this assert assuming we can't get messed up by a waitOp.
    //SkASSERT(!fCurrentCBIsEmpty || scissor);
 
    auto dimensions = fFramebuffer->colorAttachment()->dimensions();
    // We always do a sub rect clear with clearAttachments since we are inside a render pass
    VkClearRect clearRect;
    // Flip rect if necessary
    SkIRect vkRect;
    if (!scissor.enabled()) {
        vkRect.setSize(dimensions);
    } else if (kBottomLeft_GrSurfaceOrigin != fOrigin) {
        vkRect = scissor.rect();
    } else {
        vkRect.setLTRB(scissor.rect().fLeft, dimensions.height() - scissor.rect().fBottom,
                       scissor.rect().fRight, dimensions.height() - scissor.rect().fTop);
    }
    clearRect.rect.offset = { vkRect.fLeft, vkRect.fTop };
    clearRect.rect.extent = { (uint32_t)vkRect.width(), (uint32_t)vkRect.height() };
    clearRect.baseArrayLayer = 0;
    clearRect.layerCount = 1;
 
    uint32_t colorIndex;
    SkAssertResult(fCurrentRenderPass->colorAttachmentIndex(&colorIndex));
 
    VkClearAttachment attachment;
    attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    attachment.colorAttachment = colorIndex;
    attachment.clearValue.color = vkColor;
 
    this->currentCommandBuffer()->clearAttachments(fGpu, 1, &attachment, 1, &clearRect);
    fCurrentCBIsEmpty = false;
}

◆ onClearStencilClip()

void GrVkOpsRenderPass::onClearStencilClip	(	const GrScissorState &	scissor,
		bool	insideStencilMask
	)

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 432 of file GrVkOpsRenderPass.cpp.

                                                                                                {
    if (!fCurrentRenderPass) {
        SkASSERT(fGpu->isDeviceLost());
        return;
    }
 
    GrAttachment* sb = fFramebuffer->stencilAttachment();
    // this should only be called internally when we know we have a
    // stencil buffer.
    SkASSERT(sb);
    int stencilBitCount = GrBackendFormatStencilBits(sb->backendFormat());
 
    // The contract with the callers does not guarantee that we preserve all bits in the stencil
    // during this clear. Thus we will clear the entire stencil to the desired value.
 
    VkClearDepthStencilValue vkStencilColor;
    memset(&vkStencilColor, 0, sizeof(VkClearDepthStencilValue));
    if (insideStencilMask) {
        vkStencilColor.stencil = (1 << (stencilBitCount - 1));
    } else {
        vkStencilColor.stencil = 0;
    }
 
    VkClearRect clearRect;
    // Flip rect if necessary
    SkIRect vkRect;
    if (!scissor.enabled()) {
        vkRect.setXYWH(0, 0, sb->width(), sb->height());
    } else if (kBottomLeft_GrSurfaceOrigin != fOrigin) {
        vkRect = scissor.rect();
    } else {
        vkRect.setLTRB(scissor.rect().fLeft, sb->height() - scissor.rect().fBottom,
                       scissor.rect().fRight, sb->height() - scissor.rect().fTop);
    }
 
    clearRect.rect.offset = { vkRect.fLeft, vkRect.fTop };
    clearRect.rect.extent = { (uint32_t)vkRect.width(), (uint32_t)vkRect.height() };
 
    clearRect.baseArrayLayer = 0;
    clearRect.layerCount = 1;
 
    uint32_t stencilIndex;
    SkAssertResult(fCurrentRenderPass->stencilAttachmentIndex(&stencilIndex));
 
    VkClearAttachment attachment;
    attachment.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
    attachment.colorAttachment = 0; // this value shouldn't matter
    attachment.clearValue.depthStencil = vkStencilColor;
 
    this->currentCommandBuffer()->clearAttachments(fGpu, 1, &attachment, 1, &clearRect);
    fCurrentCBIsEmpty = false;
}

◆ onDraw()

void GrVkOpsRenderPass::onDraw	(	int	vertexCount,
		int	baseVertex
	)

inlineoverrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 77 of file GrVkOpsRenderPass.h.

                                                          {
        this->onDrawInstanced(1, 0, vertexCount, baseVertex);
    }

◆ onDrawIndexed()

void GrVkOpsRenderPass::onDrawIndexed	(	int	indexCount,
		int	baseIndex,
		uint16_t	minIndexValue,
		uint16_t	maxIndexValue,
		int	baseVertex
	)

inlineoverrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 80 of file GrVkOpsRenderPass.h.

                                                                        {
        this->onDrawIndexedInstanced(indexCount, baseIndex, 1, 0, baseVertex);
    }

◆ onDrawIndexedIndirect()

void GrVkOpsRenderPass::onDrawIndexedIndirect	(	const GrBuffer *	drawIndirectBuffer,
		size_t	offset,
		int	drawCount
	)

overrideprivatevirtual

Reimplemented from GrOpsRenderPass.

Definition at line 820 of file GrVkOpsRenderPass.cpp.

                                                             {
    SkASSERT(!drawIndirectBuffer->isCpuBuffer());
    if (!fCurrentRenderPass) {
        SkASSERT(fGpu->isDeviceLost());
        return;
    }
    const GrVkCaps& caps = fGpu->vkCaps();
    SkASSERT(caps.nativeDrawIndirectSupport());
    SkASSERT(fCurrentPipelineState);
    const uint32_t maxDrawCount = caps.maxDrawIndirectDrawCount();
    uint32_t remainingDraws = drawCount;
    const size_t stride = sizeof(GrDrawIndexedIndirectCommand);
    while (remainingDraws >= 1) {
        uint32_t currDrawCount = std::min(remainingDraws, maxDrawCount);
        this->currentCommandBuffer()->drawIndexedIndirect(
                fGpu, sk_ref_sp(drawIndirectBuffer), offset, currDrawCount, stride);
        remainingDraws -= currDrawCount;
        offset += stride * currDrawCount;
        fGpu->stats()->incNumDraws();
    }
    fCurrentCBIsEmpty = false;
}

◆ onDrawIndexedInstanced()

void GrVkOpsRenderPass::onDrawIndexedInstanced	(	int	indexCount,
		int	baseIndex,
		int	instanceCount,
		int	baseInstance,
		int	baseVertex
	)

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 782 of file GrVkOpsRenderPass.cpp.

                                                                                 {
    if (!fCurrentRenderPass) {
        SkASSERT(fGpu->isDeviceLost());
        return;
    }
    SkASSERT(fCurrentPipelineState);
    this->currentCommandBuffer()->drawIndexed(fGpu, indexCount, instanceCount,
                                              baseIndex, baseVertex, baseInstance);
    fGpu->stats()->incNumDraws();
    fCurrentCBIsEmpty = false;
}

◆ onDrawIndirect()

void GrVkOpsRenderPass::onDrawIndirect	(	const GrBuffer *	drawIndirectBuffer,
		size_t	offset,
		int	drawCount
	)

overrideprivatevirtual

Reimplemented from GrOpsRenderPass.

Definition at line 795 of file GrVkOpsRenderPass.cpp.

                                                      {
    SkASSERT(!drawIndirectBuffer->isCpuBuffer());
    if (!fCurrentRenderPass) {
        SkASSERT(fGpu->isDeviceLost());
        return;
    }
    const GrVkCaps& caps = fGpu->vkCaps();
    SkASSERT(caps.nativeDrawIndirectSupport());
    SkASSERT(fCurrentPipelineState);
 
    const uint32_t maxDrawCount = caps.maxDrawIndirectDrawCount();
    uint32_t remainingDraws = drawCount;
    const size_t stride = sizeof(GrDrawIndirectCommand);
    while (remainingDraws >= 1) {
        uint32_t currDrawCount = std::min(remainingDraws, maxDrawCount);
        this->currentCommandBuffer()->drawIndirect(
                fGpu, sk_ref_sp(drawIndirectBuffer), offset, currDrawCount, stride);
        remainingDraws -= currDrawCount;
        offset += stride * currDrawCount;
        fGpu->stats()->incNumDraws();
    }
    fCurrentCBIsEmpty = false;
}

◆ onDrawInstanced()

void GrVkOpsRenderPass::onDrawInstanced	(	int	instanceCount,
		int	baseInstance,
		int	vertexCount,
		int	baseVertex
	)

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 769 of file GrVkOpsRenderPass.cpp.

                                                                         {
    if (!fCurrentRenderPass) {
        SkASSERT(fGpu->isDeviceLost());
        return;
    }
    SkASSERT(fCurrentPipelineState);
    this->currentCommandBuffer()->draw(fGpu, vertexCount, instanceCount, baseVertex, baseInstance);
    fGpu->stats()->incNumDraws();
    fCurrentCBIsEmpty = false;
}

◆ onEnd()

void GrVkOpsRenderPass::onEnd ( )

overrideprivatevirtual

Reimplemented from GrOpsRenderPass.

Definition at line 620 of file GrVkOpsRenderPass.cpp.

                              {
    if (fCurrentSecondaryCommandBuffer && !this->wrapsSecondaryCommandBuffer()) {
        fCurrentSecondaryCommandBuffer->end(fGpu);
    }
}

◆ onExecuteDrawable()

void GrVkOpsRenderPass::onExecuteDrawable ( std::unique_ptr< SkDrawable::GpuDrawHandler > drawable )

overridevirtual

Reimplemented from GrOpsRenderPass.

Definition at line 846 of file GrVkOpsRenderPass.cpp.

                                                                                          {
    if (!fCurrentRenderPass) {
        SkASSERT(fGpu->isDeviceLost());
        return;
    }
 
    VkRect2D bounds;
    bounds.offset = { 0, 0 };
    bounds.extent = { 0, 0 };
 
    if (!fCurrentSecondaryCommandBuffer) {
        fGpu->endRenderPass(fRenderTarget, fOrigin, fBounds);
        this->addAdditionalRenderPass(true);
        // We may have failed to start a new render pass
        if (!fCurrentRenderPass) {
            SkASSERT(fGpu->isDeviceLost());
            return;
        }
    }
    SkASSERT(fCurrentSecondaryCommandBuffer);
 
    GrVkDrawableInfo vkInfo;
    vkInfo.fSecondaryCommandBuffer = fCurrentSecondaryCommandBuffer->vkCommandBuffer();
    vkInfo.fCompatibleRenderPass = fCurrentRenderPass->vkRenderPass();
    SkAssertResult(fCurrentRenderPass->colorAttachmentIndex(&vkInfo.fColorAttachmentIndex));
    vkInfo.fFormat = fFramebuffer->colorAttachment()->imageFormat();
    vkInfo.fDrawBounds = &bounds;
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
    vkInfo.fFromSwapchainOrAndroidWindow =
            fFramebuffer->colorAttachment()->vkImageInfo().fPartOfSwapchainOrAndroidWindow;
#endif //SK_BUILD_FOR_ANDROID_FRAMEWORK
 
    GrBackendDrawableInfo info(vkInfo);
 
    // After we draw into the command buffer via the drawable, cached state we have may be invalid.
    this->currentCommandBuffer()->invalidateState();
    // Also assume that the drawable produced output.
    fCurrentCBIsEmpty = false;
 
    drawable->draw(info);
    fGpu->addDrawable(std::move(drawable));
}

◆ onSetScissorRect()

void GrVkOpsRenderPass::onSetScissorRect ( const SkIRect & scissor )

overrideprivatevirtual

Implements GrOpsRenderPass.

Definition at line 675 of file GrVkOpsRenderPass.cpp.

                                                               {
    SkIRect combinedScissorRect;
    if (!combinedScissorRect.intersect(fCurrentPipelineBounds, scissor)) {
        combinedScissorRect = SkIRect::MakeEmpty();
    }
    GrVkPipeline::SetDynamicScissorRectState(fGpu, this->currentCommandBuffer(),
                                             fFramebuffer->colorAttachment()->dimensions(),
                                             fOrigin, combinedScissorRect);
}

◆ reset()

void GrVkOpsRenderPass::reset ( )

Definition at line 400 of file GrVkOpsRenderPass.cpp.

                              {
    if (fCurrentSecondaryCommandBuffer) {
        // The active GrVkCommandPool on the GrVkGpu should still be the same pool we got the
        // secondary command buffer from since we haven't submitted any work yet.
        SkASSERT(fGpu->cmdPool());
        fCurrentSecondaryCommandBuffer.release()->recycle(fGpu->cmdPool());
    }
    if (fCurrentRenderPass) {
        fCurrentRenderPass->unref();
        fCurrentRenderPass = nullptr;
    }
    fCurrentCBIsEmpty = true;
 
    fRenderTarget = nullptr;
    fFramebuffer.reset();
 
    fSelfDependencyFlags = GrVkRenderPass::SelfDependencyFlags::kNone;
 
    fLoadFromResolve = LoadFromResolve::kNo;
    fOverridePipelinesForResolveLoad = false;
 
#ifdef SK_DEBUG
    fIsActive = false;
#endif
}

◆ set()

bool GrVkOpsRenderPass::set	(	GrRenderTarget *	rt,
		sk_sp< GrVkFramebuffer >	framebuffer,
		GrSurfaceOrigin	origin,
		const SkIRect &	bounds,
		const GrOpsRenderPass::LoadAndStoreInfo &	colorInfo,
		const GrOpsRenderPass::StencilLoadAndStoreInfo &	stencilInfo,
		const GrOpsRenderPass::LoadAndStoreInfo &	resolveInfo,
		GrVkRenderPass::SelfDependencyFlags	selfDepFlags,
		GrVkRenderPass::LoadFromResolve	loadFromResolve,
		const skia_private::TArray< GrSurfaceProxy *, true > &	sampledProxies
	)

Definition at line 344 of file GrVkOpsRenderPass.cpp.

                                                                                 {
    SkASSERT(!fRenderTarget);
    SkASSERT(fGpu == rt->getContext()->priv().getGpu());
 
#ifdef SK_DEBUG
    fIsActive = true;
#endif
 
    // We check to make sure the GrVkGpu has a valid current command buffer instead of each time we
    // access it. If the command buffer is valid here should be valid throughout the use of the
    // render pass since nothing should trigger a submit while this render pass is active.
    if (!fGpu->currentCommandBuffer()) {
        return false;
    }
 
    this->INHERITED::set(rt, origin);
 
    for (int i = 0; i < sampledProxies.size(); ++i) {
        if (sampledProxies[i]->isInstantiated()) {
            SkASSERT(sampledProxies[i]->asTextureProxy());
            GrVkTexture* vkTex = static_cast<GrVkTexture*>(sampledProxies[i]->peekTexture());
            SkASSERT(vkTex);
            GrVkImage* texture = vkTex->textureImage();
            SkASSERT(texture);
            texture->setImageLayout(
                    fGpu, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_ACCESS_SHADER_READ_BIT,
                    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, false);
        }
    }
 
    SkASSERT(framebuffer);
    fFramebuffer = std::move(framebuffer);
 
    SkASSERT(bounds.isEmpty() ||
             SkIRect::MakeSize(fFramebuffer->colorAttachment()->dimensions()).contains(bounds));
    fBounds = bounds;
 
    fSelfDependencyFlags = selfDepFlags;
    fLoadFromResolve = loadFromResolve;
 
    if (this->wrapsSecondaryCommandBuffer()) {
        return this->initWrapped();
    }
 
    return this->init(colorInfo, resolveInfo, stencilInfo);
}

◆ submit()

void GrVkOpsRenderPass::submit ( )

Definition at line 319 of file GrVkOpsRenderPass.cpp.

                               {
    if (!fRenderTarget) {
        return;
    }
    if (!fCurrentRenderPass) {
        SkASSERT(fGpu->isDeviceLost());
        return;
    }
 
    // We don't want to actually submit the secondary command buffer if it is wrapped.
    if (this->wrapsSecondaryCommandBuffer()) {
        // We pass the ownership of the GrVkSecondaryCommandBuffer to the external framebuffer
        // since it's lifetime matches the lifetime we need to keep the GrManagedResources on the
        // GrVkSecondaryCommandBuffer alive.
        fFramebuffer->returnExternalGrSecondaryCommandBuffer(
                std::move(fCurrentSecondaryCommandBuffer));
        return;
    }
 
    if (fCurrentSecondaryCommandBuffer) {
        fGpu->submitSecondaryCommandBuffer(std::move(fCurrentSecondaryCommandBuffer));
    }
    fGpu->endRenderPass(fRenderTarget, fOrigin, fBounds);
}

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

third_party/skia/src/gpu/ganesh/vk/GrVkOpsRenderPass.h
third_party/skia/src/gpu/ganesh/vk/GrVkOpsRenderPass.cpp

Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GrVkOpsRenderPass()

◆ ~GrVkOpsRenderPass()

Member Function Documentation

◆ gpu()

◆ inlineUpload()

◆ onBindBuffers()

◆ onBindPipeline()

◆ onBindTextures()

◆ onClear()

◆ onClearStencilClip()

◆ onDraw()

◆ onDrawIndexed()

◆ onDrawIndexedIndirect()

◆ onDrawIndexedInstanced()

◆ onDrawIndirect()

◆ onDrawInstanced()

◆ onEnd()

◆ onExecuteDrawable()

◆ onSetScissorRect()

◆ reset()

◆ set()

◆ submit()