#include <GrVkRenderTarget.h>

Inheritance diagram for GrVkRenderTarget:

Public Types
using	SelfDependencyFlags = GrVkRenderPass::SelfDependencyFlags

using	LoadFromResolve = GrVkRenderPass::LoadFromResolve

Public Types inherited from GrSurface
typedef void *	ReleaseCtx

typedef void(*	ReleaseProc) (ReleaseCtx)

Public Types inherited from GrIORef< GrGpuResource >
enum	LastRemovedRef

Public Member Functions
	~GrVkRenderTarget () override

GrBackendFormat	backendFormat () const override

const GrVkFramebuffer *	getFramebuffer (bool withResolve, bool withStencil, SelfDependencyFlags selfDepFlags, LoadFromResolve)

const GrVkFramebuffer *	getFramebuffer (const GrVkRenderPass &renderPass)

GrVkImage *	colorAttachment () const

const GrVkImageView *	colorAttachmentView () const

GrVkImage *	resolveAttachment () const

const GrVkImageView *	resolveAttachmentView () const

GrVkImage *	nonMSAAAttachment () const

GrVkImage *	externalAttachment () const

const GrVkRenderPass *	getSimpleRenderPass (bool withResolve, bool withStencil, SelfDependencyFlags selfDepFlags, LoadFromResolve)

GrVkResourceProvider::CompatibleRPHandle	compatibleRenderPassHandle (bool withResolve, bool withStencil, SelfDependencyFlags selfDepFlags, LoadFromResolve)

bool	wrapsSecondaryCommandBuffer () const

sk_sp< GrVkFramebuffer >	externalFramebuffer () const

bool	canAttemptStencilAttachment (bool useMSAASurface) const override

GrBackendRenderTarget	getBackendRenderTarget () const override

bool	getAttachmentsDescriptor (GrVkRenderPass::AttachmentsDescriptor desc, GrVkRenderPass::AttachmentFlags flags, bool withResolve, bool withStencil)

Public Member Functions inherited from GrRenderTarget
virtual bool	alwaysClearStencil () const

GrRenderTarget *	asRenderTarget () override

const GrRenderTarget *	asRenderTarget () const override

int	numSamples () const

GrAttachment *	getStencilAttachment (bool useMSAASurface) const

GrAttachment *	getStencilAttachment () const

void	attachStencilAttachment (sk_sp< GrAttachment > stencil, bool useMSAASurface)

int	numStencilBits (bool useMSAASurface) const

int	getSamplePatternKey ()

const skia_private::TArray< SkPoint > &	getSampleLocations ()

void	setRequiresManualMSAAResolve ()

bool	requiresManualMSAAResolve () const

Public Member Functions inherited from GrSurface
SkISize	dimensions () const

int	width () const

int	height () const

SkRect	getBoundsRect () const

void	setRelease (sk_sp< skgpu::RefCntedCallback > releaseHelper)

void	setRelease (ReleaseProc proc, ReleaseCtx ctx)

virtual GrTexture *	asTexture ()

virtual const GrTexture *	asTexture () const

GrInternalSurfaceFlags	flags () const

bool	readOnly () const

bool	framebufferOnly () const

bool	isProtected () const

void	setFramebufferOnly ()

Public Member Functions inherited from GrGpuResource
bool	wasDestroyed () const

const GrDirectContext *	getContext () const

GrDirectContext *	getContext ()

size_t	gpuMemorySize () const

UniqueID	uniqueID () const

const skgpu::UniqueKey &	getUniqueKey () const

std::string	getLabel () const

void	setLabel (std::string_view label)

CacheAccess	cacheAccess ()

const CacheAccess	cacheAccess () const

ProxyAccess	proxyAccess ()

ResourcePriv	resourcePriv ()

const ResourcePriv	resourcePriv () const

virtual void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const

Public Member Functions inherited from GrIORef< GrGpuResource >
bool	unique () const

void	ref () const

void	unref () const

void	refCommandBuffer () const

void	unrefCommandBuffer () const

Public Member Functions inherited from SkNoncopyable
	SkNoncopyable ()=default

	SkNoncopyable (SkNoncopyable &&)=default

SkNoncopyable &	operator= (SkNoncopyable &&)=default

Static Public Member Functions
static sk_sp< GrVkRenderTarget >	MakeWrappedRenderTarget (GrVkGpu *, SkISize, int sampleCnt, const GrVkImageInfo &, sk_sp< skgpu::MutableTextureState >)

static sk_sp< GrVkRenderTarget >	MakeSecondaryCBRenderTarget (GrVkGpu *, SkISize, const GrVkDrawableInfo &vkInfo)

static void	ReconstructAttachmentsDescriptor (const GrVkCaps &vkCaps, const GrProgramInfo &programInfo, GrVkRenderPass::AttachmentsDescriptor desc, GrVkRenderPass::AttachmentFlags flags)

Static Public Member Functions inherited from GrSurface
static size_t	ComputeSize (const GrBackendFormat &, SkISize dimensions, int colorSamplesPerPixel, skgpu::Mipmapped, bool binSize=false)

Static Public Member Functions inherited from GrGpuResource
static uint32_t	CreateUniqueID ()

Protected Types
enum class	CreateType { kDirectlyWrapped , kFromTextureRT }

Protected Member Functions
	GrVkRenderTarget (GrVkGpu *gpu, SkISize dimensions, sk_sp< GrVkImage > colorAttachment, sk_sp< GrVkImage > resolveImage, CreateType createType, std::string_view label)

void	onAbandon () override

void	onRelease () override

size_t	onGpuMemorySize () const override

void	onSetLabel () override

Protected Member Functions inherited from GrRenderTarget
	GrRenderTarget (GrGpu *, const SkISize &, int sampleCount, GrProtected, std::string_view label, sk_sp< GrAttachment > stenicl=nullptr)

	~GrRenderTarget () override

Protected Member Functions inherited from GrSurface
void	setGLRTFBOIDIs0 ()

bool	glRTFBOIDis0 () const

void	setRequiresManualMSAAResolve ()

bool	requiresManualMSAAResolve () const

void	setReadOnly ()

void	setVkRTSupportsInputAttachment ()

	GrSurface (GrGpu *gpu, const SkISize &dimensions, skgpu::Protected isProtected, std::string_view label)

	~GrSurface () override

Protected Member Functions inherited from GrGpuResource
void	registerWithCache (skgpu::Budgeted)

void	registerWithCacheWrapped (GrWrapCacheable)

	GrGpuResource (GrGpu *, std::string_view label)

virtual	~GrGpuResource ()

GrGpu *	getGpu () const

virtual void	setMemoryBacking (SkTraceMemoryDump *, const SkString &) const

SkString	getResourceName () const

void	dumpMemoryStatisticsPriv (SkTraceMemoryDump traceMemoryDump, const SkString &resourceName, const char type, size_t size) const

Protected Member Functions inherited from GrIORef< GrGpuResource >
	GrIORef ()

bool	internalHasRef () const

bool	internalHasNoCommandBufferUsages () const

void	addInitialRef () const

Private Member Functions
bool	completeStencilAttachment (GrAttachment *stencil, bool useMSAASurface) override

void	onSetRelease (sk_sp< RefCntedReleaseProc > releaseHelper) override

Detailed Description

Definition at line 26 of file GrVkRenderTarget.h.

Member Typedef Documentation

◆ LoadFromResolve

using GrVkRenderTarget::LoadFromResolve = GrVkRenderPass::LoadFromResolve

Definition at line 43 of file GrVkRenderTarget.h.

◆ SelfDependencyFlags

using GrVkRenderTarget::SelfDependencyFlags = GrVkRenderPass::SelfDependencyFlags

Definition at line 42 of file GrVkRenderTarget.h.

Member Enumeration Documentation

◆ CreateType

enum class GrVkRenderTarget::CreateType

strongprotected

Enumerator
kDirectlyWrapped
kFromTextureRT

Definition at line 118 of file GrVkRenderTarget.h.

                          {
        kDirectlyWrapped, // We need to register this in the ctor
        kFromTextureRT,   // Skip registering this to cache since TexRT will handle it
    };

Constructor & Destructor Documentation

◆ ~GrVkRenderTarget()

GrVkRenderTarget::~GrVkRenderTarget ( )

override

Definition at line 470 of file GrVkRenderTarget.cpp.

                                    {
    // either release or abandon should have been called by the owner of this object.
    SkASSERT(!fColorAttachment);
    SkASSERT(!fResolveAttachment);
    SkASSERT(!fDynamicMSAAAttachment);
 
    for (int i = 0; i < kNumCachedFramebuffers; ++i) {
        SkASSERT(!fCachedFramebuffers[i]);
    }
 
    SkASSERT(!fCachedInputDescriptorSet);
}

◆ GrVkRenderTarget()

GrVkRenderTarget::GrVkRenderTarget	(	GrVkGpu *	gpu,
		SkISize	dimensions,
		sk_sp< GrVkImage >	colorAttachment,
		sk_sp< GrVkImage >	resolveImage,
		CreateType	createType,
		std::string_view	label
	)

protected

Definition at line 54 of file GrVkRenderTarget.cpp.

        : GrSurface(gpu,
                    dimensions,
                    colorAttachment->isProtected() ? GrProtected::kYes : GrProtected::kNo,
                    label)
        // for the moment we only support 1:1 color to stencil
        , GrRenderTarget(gpu,
                         dimensions,
                         colorAttachment->numSamples(),
                         colorAttachment->isProtected() ? GrProtected::kYes : GrProtected::kNo,
                         label)
        , fColorAttachment(std::move(colorAttachment))
        , fResolveAttachment(std::move(resolveAttachment))
        , fCachedFramebuffers() {
    SkASSERT(fColorAttachment);
 
    if (fColorAttachment->numSamples() == 1 && fColorAttachment->supportsInputAttachmentUsage()) {
        SkASSERT(!fResolveAttachment);
        // When we have a single sampled color attachment, we set both the color and resolve
        // to the same attachment. This way if we use DMAA on this render target we will resolve
        // to the single target attachment.
        fResolveAttachment = fColorAttachment;
    }
 
    SkASSERT(!fResolveAttachment ||
             (fResolveAttachment->isProtected() == fColorAttachment->isProtected()));
    SkASSERT(SkToBool(fColorAttachment->vkUsageFlags() & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT));
    this->setFlags();
    if (createType == CreateType::kDirectlyWrapped) {
        this->registerWithCacheWrapped(GrWrapCacheable::kNo);
    }
}

Member Function Documentation

◆ backendFormat()

GrBackendFormat GrVkRenderTarget::backendFormat ( ) const

overridevirtual

Implements GrSurface.

Reimplemented in GrVkTextureRenderTarget.

Definition at line 226 of file GrVkRenderTarget.cpp.

                                                      {
    if (this->wrapsSecondaryCommandBuffer()) {
        return fExternalFramebuffer->colorAttachment()->backendFormat();
    }
    return fColorAttachment->backendFormat();
}

◆ canAttemptStencilAttachment()

bool GrVkRenderTarget::canAttemptStencilAttachment ( bool useMSAASurface ) const

overridevirtual

Implements GrRenderTarget.

Definition at line 274 of file GrVkRenderTarget.cpp.

                                                                            {
    SkASSERT(!useMSAASurface || this->numSamples() > 1 ||
             this->getVkGpu()->vkCaps().supportsDiscardableMSAAForDMSAA());
    if (!useMSAASurface && this->numSamples() > 1) {
        return false;
    }
    bool validMSAA = true;
    if (useMSAASurface) {
        validMSAA = this->numSamples() > 1 ||
                    (this->getVkGpu()->vkCaps().supportsDiscardableMSAAForDMSAA() &&
                     this->colorAttachment()->supportsInputAttachmentUsage());
    }
    // We don't know the status of the stencil attachment for wrapped external secondary command
    // buffers so we just assume we don't have one.
    return validMSAA && !this->wrapsSecondaryCommandBuffer();
}

◆ colorAttachment()

GrVkImage * GrVkRenderTarget::colorAttachment ( ) const

inline

Definition at line 56 of file GrVkRenderTarget.h.

                                       {
        SkASSERT(!this->wrapsSecondaryCommandBuffer());
        return fColorAttachment.get();
    }

◆ colorAttachmentView()

const GrVkImageView * GrVkRenderTarget::colorAttachmentView ( ) const

inline

Definition at line 60 of file GrVkRenderTarget.h.

                                                     {
        SkASSERT(!this->wrapsSecondaryCommandBuffer());
        return this->colorAttachment()->framebufferView();
    }

◆ compatibleRenderPassHandle()

GrVkResourceProvider::CompatibleRPHandle GrVkRenderTarget::compatibleRenderPassHandle	(	bool	withResolve,
		bool	withStencil,
		SelfDependencyFlags	selfDepFlags,
		LoadFromResolve	loadFromResolve
	)

Definition at line 303 of file GrVkRenderTarget.cpp.

                                         {
    SkASSERT(!this->wrapsSecondaryCommandBuffer());
 
    const GrVkFramebuffer* fb =
            this->getFramebuffer(withResolve, withStencil, selfDepFlags, loadFromResolve);
    if (!fb) {
        return {};
    }
 
    return fb->compatibleRenderPassHandle();
}

◆ completeStencilAttachment()

bool GrVkRenderTarget::completeStencilAttachment	(	GrAttachment *	stencil,
		bool	useMSAASurface
	)

overrideprivatevirtual

Implements GrRenderTarget.

Definition at line 291 of file GrVkRenderTarget.cpp.

                                                                                           {
    SkASSERT(!this->wrapsSecondaryCommandBuffer());
    SkASSERT(!useMSAASurface ||
             this->numSamples() > 1 ||
             this->getVkGpu()->vkCaps().supportsDiscardableMSAAForDMSAA());
    return true;
}

◆ externalAttachment()

GrVkImage * GrVkRenderTarget::externalAttachment ( ) const

inline

Definition at line 82 of file GrVkRenderTarget.h.

                                          {
        return fResolveAttachment ? fResolveAttachment.get() : fColorAttachment.get();
    }

◆ externalFramebuffer()

sk_sp< GrVkFramebuffer > GrVkRenderTarget::externalFramebuffer ( ) const

Definition at line 299 of file GrVkRenderTarget.cpp.

                                                                   {
    return fExternalFramebuffer;
}

◆ getAttachmentsDescriptor()

bool GrVkRenderTarget::getAttachmentsDescriptor	(	GrVkRenderPass::AttachmentsDescriptor *	desc,
		GrVkRenderPass::AttachmentFlags *	flags,
		bool	withResolve,
		bool	withStencil
	)

Definition at line 399 of file GrVkRenderTarget.cpp.

                                                                  {
    SkASSERT(!this->wrapsSecondaryCommandBuffer());
    const GrVkImage* colorAttachment =
            withResolve ? this->msaaAttachment() : this->colorAttachment();
    if (!colorAttachment) {
        SkDebugf("WARNING: Invalid color attachment -- possibly dmsaa attachment creation failed?");
        return false;
    }
 
    desc->fColor.fFormat = colorAttachment->imageFormat();
    desc->fColor.fSamples = colorAttachment->numSamples();
    *attachmentFlags = GrVkRenderPass::kColor_AttachmentFlag;
    uint32_t attachmentCount = 1;
 
    if (withResolve) {
        desc->fResolve.fFormat = desc->fColor.fFormat;
        desc->fResolve.fSamples = 1;
        *attachmentFlags |= GrVkRenderPass::kResolve_AttachmentFlag;
        ++attachmentCount;
    }
 
    if (withStencil) {
        bool useMSAA = this->numSamples() > 1 || withResolve;
        const GrAttachment* stencil = this->getStencilAttachment(useMSAA);
        SkASSERT(stencil);
        const GrVkImage* vkStencil = static_cast<const GrVkImage*>(stencil);
        desc->fStencil.fFormat = vkStencil->imageFormat();
        desc->fStencil.fSamples = vkStencil->numSamples();
        SkASSERT(desc->fStencil.fSamples == desc->fColor.fSamples);
        *attachmentFlags |= GrVkRenderPass::kStencil_AttachmentFlag;
        ++attachmentCount;
    }
    desc->fAttachmentCount = attachmentCount;
 
    return true;
}

◆ getBackendRenderTarget()

GrBackendRenderTarget GrVkRenderTarget::getBackendRenderTarget ( ) const

overridevirtual

Implements GrRenderTarget.

Definition at line 512 of file GrVkRenderTarget.cpp.

                                                                     {
    SkASSERT(!this->wrapsSecondaryCommandBuffer());
    // This should only get called with a non-released GrVkRenderTargets.
    SkASSERT(!this->wasDestroyed());
    // If we have a resolve attachment that is what we return for the backend render target
    const GrVkImage* beAttachment = this->externalAttachment();
    return GrBackendRenderTargets::MakeVk(beAttachment->width(),
                                          beAttachment->height(),
                                          beAttachment->vkImageInfo(),
                                          beAttachment->getMutableState());
}

◆ getFramebuffer() [1/2]

const GrVkFramebuffer * GrVkRenderTarget::getFramebuffer	(	bool	withResolve,
		bool	withStencil,
		SelfDependencyFlags	selfDepFlags,
		LoadFromResolve	loadFromResolve
	)

Definition at line 353 of file GrVkRenderTarget.cpp.

                                                                                         {
    int cacheIndex =
            renderpass_features_to_index(withResolve, withStencil, selfDepFlags, loadFromResolve);
    SkASSERT(cacheIndex < GrVkRenderTarget::kNumCachedFramebuffers);
    if (auto fb = fCachedFramebuffers[cacheIndex]) {
        return fb.get();
    }
 
    this->createFramebuffer(withResolve, withStencil, selfDepFlags, loadFromResolve);
    return fCachedFramebuffers[cacheIndex].get();
}

◆ getFramebuffer() [2/2]

const GrVkFramebuffer * GrVkRenderTarget::getFramebuffer ( const GrVkRenderPass & renderPass )

inline

Definition at line 49 of file GrVkRenderTarget.h.

                                                                            {
        return this->getFramebuffer(renderPass.hasResolveAttachment(),
                                    renderPass.hasStencilAttachment(),
                                    renderPass.selfDependencyFlags(),
                                    renderPass.loadFromResolve());
    }

◆ getSimpleRenderPass()

const GrVkRenderPass * GrVkRenderTarget::getSimpleRenderPass	(	bool	withResolve,
		bool	withStencil,
		SelfDependencyFlags	selfDepFlags,
		LoadFromResolve	loadFromResolve
	)

Definition at line 319 of file GrVkRenderTarget.cpp.

                                                                                             {
    if (this->wrapsSecondaryCommandBuffer()) {
         return fExternalFramebuffer->externalRenderPass();
    }
 
    const GrVkFramebuffer* fb =
            this->getFramebuffer(withResolve, withStencil, selfDepFlags, loadFromResolve);
    if (!fb) {
        return nullptr;
    }
 
    return fb->compatibleRenderPass();
}

◆ MakeSecondaryCBRenderTarget()

sk_sp< GrVkRenderTarget > GrVkRenderTarget::MakeSecondaryCBRenderTarget	(	GrVkGpu *	gpu,
		SkISize	dimensions,
		const GrVkDrawableInfo &	vkInfo
	)

static

Definition at line 174 of file GrVkRenderTarget.cpp.

                                                                          {
    const GrVkRenderPass* rp = gpu->resourceProvider().findCompatibleExternalRenderPass(
            vkInfo.fCompatibleRenderPass, vkInfo.fColorAttachmentIndex);
    if (!rp) {
        return nullptr;
    }
 
    if (vkInfo.fSecondaryCommandBuffer == VK_NULL_HANDLE) {
        return nullptr;
    }
 
    // We only set the few properties of the GrVkImageInfo that we know like layout and format. The
    // others we keep at the default "null" values.
    GrVkImageInfo info;
    info.fImageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
    info.fFormat = vkInfo.fFormat;
    info.fImageUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
                            VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
 
    auto mutableState =
            sk_make_sp<skgpu::MutableTextureState>(skgpu::MutableTextureStates::MakeVulkan(
                    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_QUEUE_FAMILY_IGNORED));
 
    sk_sp<GrVkImage> colorAttachment =
            GrVkImage::MakeWrapped(gpu,
                                   dimensions,
                                   info,
                                   std::move(mutableState),
                                   GrAttachment::UsageFlags::kColorAttachment,
                                   kBorrow_GrWrapOwnership,
                                   GrWrapCacheable::kNo,
                                   "VkImage_ColorAttachment",
                                   true);
 
    std::unique_ptr<GrVkSecondaryCommandBuffer> scb(
            GrVkSecondaryCommandBuffer::Create(vkInfo.fSecondaryCommandBuffer, rp));
    if (!scb) {
        return nullptr;
    }
 
    sk_sp<GrVkFramebuffer> framebuffer(new GrVkFramebuffer(
            gpu, std::move(colorAttachment), sk_sp<const GrVkRenderPass>(rp),
            std::move(scb)));
 
    GrVkRenderTarget* vkRT =
            new GrVkRenderTarget(gpu, dimensions, std::move(framebuffer),
                                 /*label=*/"Vk_MakeSecondaryCBRenderTarget");
 
    return sk_sp<GrVkRenderTarget>(vkRT);
}

◆ MakeWrappedRenderTarget()

sk_sp< GrVkRenderTarget > GrVkRenderTarget::MakeWrappedRenderTarget	(	GrVkGpu *	gpu,
		SkISize	dimensions,
		int	sampleCnt,
		const GrVkImageInfo &	info,
		sk_sp< skgpu::MutableTextureState >	mutableState
	)

static

Definition at line 130 of file GrVkRenderTarget.cpp.

                                                      {
    SkASSERT(VK_NULL_HANDLE != info.fImage);
    SkASSERT(1 == info.fLevelCount);
    SkASSERT(sampleCnt >= 1 && info.fSampleCount >= 1);
 
    int wrappedImageSampleCnt = static_cast<int>(info.fSampleCount);
    if (sampleCnt != wrappedImageSampleCnt && wrappedImageSampleCnt != 1) {
        return nullptr;
    }
 
    sk_sp<GrVkImage> wrappedAttachment =
            GrVkImage::MakeWrapped(gpu,
                                   dimensions,
                                   info,
                                   std::move(mutableState),
                                   GrAttachment::UsageFlags::kColorAttachment,
                                   kBorrow_GrWrapOwnership,
                                   GrWrapCacheable::kNo,
                                   /*label=*/"VkImage_WrappedAttachment");
    if (!wrappedAttachment) {
        return nullptr;
    }
 
    sk_sp<GrVkImage> colorAttachment;
    colorAttachment = std::move(wrappedAttachment);
 
    if (!colorAttachment) {
        return nullptr;
    }
 
    GrVkRenderTarget* vkRT = new GrVkRenderTarget(gpu,
                                                  dimensions,
                                                  std::move(colorAttachment),
                                                  nullptr,
                                                  CreateType::kDirectlyWrapped,
                                                  /*label=*/"Vk_MakeWrappedRenderTarget");
    return sk_sp<GrVkRenderTarget>(vkRT);
}

◆ nonMSAAAttachment()

GrVkImage * GrVkRenderTarget::nonMSAAAttachment ( ) const

Definition at line 233 of file GrVkRenderTarget.cpp.

                                                     {
    if (fColorAttachment->numSamples() == 1) {
        return fColorAttachment.get();
    } else {
        return fResolveAttachment.get();
    }
}

◆ onAbandon()

void GrVkRenderTarget::onAbandon ( )

overrideprotectedvirtual

Overridden to abandon any internal handles, ptrs, etc to backend API resources. This may be called when the underlying 3D context is no longer valid and so no backend API calls should be made.

Reimplemented from GrRenderTarget.

Reimplemented in GrVkTextureRenderTarget.

Definition at line 507 of file GrVkRenderTarget.cpp.

                                 {
    this->releaseInternalObjects();
    GrRenderTarget::onAbandon();
}

◆ onGpuMemorySize()

size_t GrVkRenderTarget::onGpuMemorySize ( ) const

inlineoverrideprotectedvirtual

Implements GrGpuResource.

Reimplemented in GrVkTextureRenderTarget.

Definition at line 134 of file GrVkRenderTarget.h.

134{ return 0; }

◆ onRelease()

void GrVkRenderTarget::onRelease ( )

overrideprotectedvirtual

Overridden to free GPU resources in the backend API.

Reimplemented from GrRenderTarget.

Reimplemented in GrVkTextureRenderTarget.

Definition at line 502 of file GrVkRenderTarget.cpp.

                                 {
    this->releaseInternalObjects();
    GrRenderTarget::onRelease();
}

◆ onSetLabel()

void GrVkRenderTarget::onSetLabel ( )

inlineoverrideprotectedvirtual

Implements GrGpuResource.

Reimplemented in GrVkTextureRenderTarget.

Definition at line 136 of file GrVkRenderTarget.h.

136{}

◆ onSetRelease()

void GrVkRenderTarget::onSetRelease ( sk_sp< RefCntedReleaseProc > releaseHelper )

inlineoverrideprivatevirtual

Reimplemented from GrSurface.

Reimplemented in GrVkTextureRenderTarget.

Definition at line 166 of file GrVkRenderTarget.h.

                                                                         {
        // Forward the release proc on to the GrVkImage of the resolve attachment if we have one,
        // otherwise the color attachment.
        GrVkImage* attachment =
                fResolveAttachment ? fResolveAttachment.get() : fColorAttachment.get();
        attachment->setResourceRelease(std::move(releaseHelper));
    }

◆ ReconstructAttachmentsDescriptor()

void GrVkRenderTarget::ReconstructAttachmentsDescriptor	(	const GrVkCaps &	vkCaps,
		const GrProgramInfo &	programInfo,
		GrVkRenderPass::AttachmentsDescriptor *	desc,
		GrVkRenderPass::AttachmentFlags *	flags
	)

static

Definition at line 439 of file GrVkRenderTarget.cpp.

                                                                                              {
    VkFormat format;
    SkAssertResult(GrBackendFormats::AsVkFormat(programInfo.backendFormat(), &format));
 
    desc->fColor.fFormat = format;
    desc->fColor.fSamples = programInfo.numSamples();
    *flags = GrVkRenderPass::kColor_AttachmentFlag;
    uint32_t attachmentCount = 1;
 
    if (vkCaps.programInfoWillUseDiscardableMSAA(programInfo)) {
        desc->fResolve.fFormat = desc->fColor.fFormat;
        desc->fResolve.fSamples = 1;
        *flags |= GrVkRenderPass::kResolve_AttachmentFlag;
        ++attachmentCount;
    }
 
    SkASSERT(!programInfo.isStencilEnabled() || programInfo.needsStencil());
    if (programInfo.needsStencil()) {
        VkFormat stencilFormat = vkCaps.preferredStencilFormat();
        desc->fStencil.fFormat = stencilFormat;
        desc->fStencil.fSamples = programInfo.numSamples();
        SkASSERT(desc->fStencil.fSamples == desc->fColor.fSamples);
        *flags |= GrVkRenderPass::kStencil_AttachmentFlag;
        ++attachmentCount;
    }
    desc->fAttachmentCount = attachmentCount;
}

◆ resolveAttachment()

GrVkImage * GrVkRenderTarget::resolveAttachment ( ) const

inline

Definition at line 65 of file GrVkRenderTarget.h.

                                         {
        SkASSERT(!this->wrapsSecondaryCommandBuffer());
        return fResolveAttachment.get();
    }

◆ resolveAttachmentView()

const GrVkImageView * GrVkRenderTarget::resolveAttachmentView ( ) const

inline

Definition at line 69 of file GrVkRenderTarget.h.

                                                       {
        SkASSERT(!this->wrapsSecondaryCommandBuffer());
        return fResolveAttachment->framebufferView();
    }

◆ wrapsSecondaryCommandBuffer()

bool GrVkRenderTarget::wrapsSecondaryCommandBuffer ( ) const

inline

Definition at line 97 of file GrVkRenderTarget.h.

97{ return SkToBool(fExternalFramebuffer); }

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

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Private Member Functions

Detailed Description

Member Typedef Documentation

◆ LoadFromResolve

◆ SelfDependencyFlags

Member Enumeration Documentation

◆ CreateType

Constructor & Destructor Documentation

◆ ~GrVkRenderTarget()

◆ GrVkRenderTarget()

Member Function Documentation

◆ backendFormat()

◆ canAttemptStencilAttachment()

◆ colorAttachment()

◆ colorAttachmentView()

◆ compatibleRenderPassHandle()

◆ completeStencilAttachment()

◆ externalAttachment()

◆ externalFramebuffer()

◆ getAttachmentsDescriptor()

◆ getBackendRenderTarget()

◆ getFramebuffer() [1/2]

◆ getFramebuffer() [2/2]

◆ getSimpleRenderPass()

◆ MakeSecondaryCBRenderTarget()

◆ MakeWrappedRenderTarget()

◆ nonMSAAAttachment()

◆ onAbandon()

◆ onGpuMemorySize()

◆ onRelease()

◆ onSetLabel()

◆ onSetRelease()

◆ ReconstructAttachmentsDescriptor()

◆ resolveAttachment()

◆ resolveAttachmentView()

◆ wrapsSecondaryCommandBuffer()