GrVkOpsRenderPass Class Reference

#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)
virtual void	inlineUpload (GrOpFlushState *, GrDeferredTextureUploadFn &)=0
void	clear (const GrScissorState &scissor, std::array< float, 4 > color)
void	clearStencilClip (const GrScissorState &scissor, bool insideStencilMask)
void	executeDrawable (std::unique_ptr< SkDrawable::GpuDrawHandler >)

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.

: fGpu(gpu) {}

~GrVkOpsRenderPass()

GrVkOpsRenderPass::~GrVkOpsRenderPass ( )

override

Definition at line 288 of file GrVkOpsRenderPass.cpp.

                                      {
    this->reset();
}

Member Function Documentation

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);
}

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));
}

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