#include <GrGLRenderTarget.h>

Inheritance diagram for GrGLRenderTarget:

Classes
struct	IDs

Public Types
enum	{ kUnresolvableFBOID = 0 }

enum class	ResolveDirection : bool { kSingleToMSAA , kMSAAToSingle }

Public Types inherited from GrSurface
typedef void *	ReleaseCtx

typedef void(*	ReleaseProc) (ReleaseCtx)

Public Types inherited from GrIORef< GrGpuResource >
enum	LastRemovedRef

Public Member Functions
bool	alwaysClearStencil () const override

bool	isFBO0 (bool multisample) const

bool	isMultisampledRenderToTexture () const

GrBackendRenderTarget	getBackendRenderTarget () const override

GrBackendFormat	backendFormat () const override

bool	canAttemptStencilAttachment (bool useMultisampleFBO) const override

void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const override

GrGLFormat	format () const

bool	hasDynamicMSAAAttachment () const

bool	ensureDynamicMSAAAttachment ()

void	bind (bool useMultisampleFBO)

bool	mustRebind (bool useMultisampleFBO) const

void	bindForPixelOps (GrGLenum fboTarget)

void	bindForResolve (ResolveDirection)

bool	glRTFBOIDis0 () const

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

GrRenderTarget *	asRenderTarget () override

const GrRenderTarget *	asRenderTarget () const override

int	numSamples () const

virtual GrBackendRenderTarget	getBackendRenderTarget () const =0

GrAttachment *	getStencilAttachment (bool useMSAASurface) const

GrAttachment *	getStencilAttachment () const

virtual bool	canAttemptStencilAttachment (bool useMSAASurface) const =0

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

virtual GrBackendFormat	backendFormat () const =0

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

void	setRelease (ReleaseProc proc, ReleaseCtx ctx)

virtual GrTexture *	asTexture ()

virtual const GrTexture *	asTexture () const

virtual GrRenderTarget *	asRenderTarget ()

virtual const GrRenderTarget *	asRenderTarget () 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

virtual const char *	getResourceType () const =0

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< GrGLRenderTarget >	MakeWrapped (GrGLGpu *, const SkISize &, GrGLFormat, int sampleCount, const IDs &, int stencilBits, skgpu::Protected, std::string_view label)

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 Member Functions
	GrGLRenderTarget (GrGLGpu *, const SkISize &, GrGLFormat, int sampleCount, const IDs &, skgpu::Protected, std::string_view label)

void	init (GrGLFormat, const IDs &)

void	bindInternal (GrGLenum fboTarget, bool useMultisampleFBO)

void	onAbandon () override

void	onRelease () override

int	totalMemorySamplesPerPixel () const

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

	~GrRenderTarget () override

void	onAbandon () override

void	onRelease () 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

void	onRelease () override

void	onAbandon () 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	onRelease ()

virtual void	onAbandon ()

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

Detailed Description

Definition at line 23 of file GrGLRenderTarget.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
kUnresolvableFBOID

Definition at line 30 of file GrGLRenderTarget.h.

30{ kUnresolvableFBOID = 0 };

GrGLRenderTarget::kUnresolvableFBOID

@ kUnresolvableFBOID

Definition: GrGLRenderTarget.h:30

◆ ResolveDirection

enum class GrGLRenderTarget::ResolveDirection : bool

strong

Enumerator
kSingleToMSAA
kMSAAToSingle

Definition at line 90 of file GrGLRenderTarget.h.

                                : bool {
        kSingleToMSAA,  // glCaps.canResolveSingleToMSAA() must be true.
        kMSAAToSingle
    };

Constructor & Destructor Documentation

◆ GrGLRenderTarget()

GrGLRenderTarget::GrGLRenderTarget	(	GrGLGpu *	gpu,
		const SkISize &	dimensions,
		GrGLFormat	format,
		int	sampleCount,
		const IDs &	ids,
		skgpu::Protected	isProtected,
		std::string_view	label
	)

protected

Definition at line 41 of file GrGLRenderTarget.cpp.

        : GrSurface(gpu, dimensions, isProtected, label)
        , GrRenderTarget(gpu, dimensions, sampleCount, isProtected, label) {
    this->init(format, ids);
    this->setFlags(gpu->glCaps(), ids);
}

Member Function Documentation

◆ alwaysClearStencil()

bool GrGLRenderTarget::alwaysClearStencil ( ) const

inlineoverridevirtual

Reimplemented from GrRenderTarget.

Definition at line 26 of file GrGLRenderTarget.h.

26{ return this->glRTFBOIDis0(); }

GrGLRenderTarget::glRTFBOIDis0

bool glRTFBOIDis0() const

Definition: GrSurface.h:117

◆ backendFormat()

GrBackendFormat GrGLRenderTarget::backendFormat ( ) const

overridevirtual

Implements GrSurface.

Reimplemented in GrGLTextureRenderTarget.

Definition at line 131 of file GrGLRenderTarget.cpp.

                                                      {
    // We should never have a GrGLRenderTarget (even a textureable one with a target that is not
    // texture 2D.
    return GrBackendFormats::MakeGL(GrGLFormatToEnum(fRTFormat), GR_GL_TEXTURE_2D);
}

◆ bind()

void GrGLRenderTarget::bind ( bool useMultisampleFBO )

inline

Definition at line 73 of file GrGLRenderTarget.h.

                                      {
        this->bindInternal(GR_GL_FRAMEBUFFER, useMultisampleFBO);
    }

◆ bindForPixelOps()

void GrGLRenderTarget::bindForPixelOps ( GrGLenum fboTarget )

inline

Definition at line 85 of file GrGLRenderTarget.h.

                                             {
        this->bindInternal(fboTarget,
                           this->numSamples() > 1 && !this->isMultisampledRenderToTexture());
    }

◆ bindForResolve()

void GrGLRenderTarget::bindForResolve ( GrGLGpu::ResolveDirection resolveDirection )

Definition at line 281 of file GrGLRenderTarget.cpp.

                                                                              {
    // If the multisample FBO is nonzero, it means we always have something to resolve (even if the
    // single sample buffer is FBO 0). If it's zero, then there's nothing to resolve.
    SkASSERT(fMultisampleFBOID != 0);
 
    // In the EXT_multisampled_render_to_texture case, we shouldn't be resolving anything.
    SkASSERT(!this->isMultisampledRenderToTexture());
 
    if (resolveDirection == GrGLGpu::ResolveDirection::kMSAAToSingle) {
        this->bindInternal(GR_GL_READ_FRAMEBUFFER, true);
        this->bindInternal(GR_GL_DRAW_FRAMEBUFFER, false);
    } else {
        SkASSERT(resolveDirection == GrGLGpu::ResolveDirection::kSingleToMSAA);
        SkASSERT(this->getGLGpu()->glCaps().canResolveSingleToMSAA());
        this->bindInternal(GR_GL_READ_FRAMEBUFFER, false);
        this->bindInternal(GR_GL_DRAW_FRAMEBUFFER, true);
    }
}

◆ bindInternal()

void GrGLRenderTarget::bindInternal	(	GrGLenum	fboTarget,
		bool	useMultisampleFBO
	)

protected

Definition at line 199 of file GrGLRenderTarget.cpp.

                                                                              {
    GrGLuint fboId = useMultisampleFBO ? fMultisampleFBOID : fSingleSampleFBOID;
    this->getGLGpu()->bindFramebuffer(fboTarget, fboId);
 
    if (fSingleSampleFBOID != 0 &&
        fSingleSampleFBOID == fMultisampleFBOID &&
        useMultisampleFBO != fDMSAARenderToTextureFBOIsMultisample) {
        auto* glTex = static_cast<GrGLTexture*>(this->asTexture());
        if (this->getGLGpu()->glCaps().bindTexture0WhenChangingTextureFBOMultisampleCount()) {
            GL_CALL(FramebufferTexture2D(fboTarget,
                                         GR_GL_COLOR_ATTACHMENT0,
                                         GR_GL_TEXTURE_2D,
                                         0 /*texture*/,
                                         0 /*mipMapLevel*/));
        }
        if (useMultisampleFBO) {
            int sampleCount = this->numSamples() > 1 ?
                    this->numSamples() :
                    this->getGpu()->caps()->internalMultisampleCount(this->backendFormat());
            GL_CALL(FramebufferTexture2DMultisample(fboTarget,
                                                    GR_GL_COLOR_ATTACHMENT0,
                                                    glTex->target(),
                                                    glTex->textureID(),
                                                    0 /*mipMapLevel*/,
                                                    sampleCount));
        } else {
            GL_CALL(FramebufferTexture2D(fboTarget,
                                         GR_GL_COLOR_ATTACHMENT0,
                                         glTex->target(),
                                         glTex->textureID(),
                                         0 /*mipMapLevel*/));
        }
        fDMSAARenderToTextureFBOIsMultisample = useMultisampleFBO;
        fNeedsStencilAttachmentBind[useMultisampleFBO] = true;
    }
 
    // Make sure the stencil attachment is valid. Even though a color buffer op doesn't use stencil,
    // our FBO still needs to be "framebuffer complete".
    if (fNeedsStencilAttachmentBind[useMultisampleFBO]) {
        if (auto stencil = this->getStencilAttachment(useMultisampleFBO)) {
            const GrGLAttachment* glStencil = static_cast<const GrGLAttachment*>(stencil);
            GL_CALL(FramebufferRenderbuffer(fboTarget,
                                            GR_GL_STENCIL_ATTACHMENT,
                                            GR_GL_RENDERBUFFER,
                                            glStencil->renderbufferID()));
            if (GrGLFormatIsPackedDepthStencil(glStencil->format())) {
                GL_CALL(FramebufferRenderbuffer(fboTarget,
                                                GR_GL_DEPTH_ATTACHMENT,
                                                GR_GL_RENDERBUFFER,
                                                glStencil->renderbufferID()));
            } else {
                GL_CALL(FramebufferRenderbuffer(fboTarget,
                                                GR_GL_DEPTH_ATTACHMENT,
                                                GR_GL_RENDERBUFFER,
                                                0));
            }
        } else {
            GL_CALL(FramebufferRenderbuffer(fboTarget,
                                            GR_GL_STENCIL_ATTACHMENT,
                                            GR_GL_RENDERBUFFER,
                                            0));
            GL_CALL(FramebufferRenderbuffer(fboTarget,
                                            GR_GL_DEPTH_ATTACHMENT,
                                            GR_GL_RENDERBUFFER,
                                            0));
        }
#ifdef SK_DEBUG
        if (!this->getGLGpu()->glCaps().skipErrorChecks() &&
            !this->getGLGpu()->glCaps().rebindColorAttachmentAfterCheckFramebufferStatus()) {
            GrGLenum status;
            GL_CALL_RET(status, CheckFramebufferStatus(fboTarget));
            if (status != GR_GL_FRAMEBUFFER_COMPLETE) {
                // This can fail if the context has been asynchronously abandoned (see
                // skbug.com/5200).
                SkDebugf("WARNING: failed to attach stencil.\n");
            }
        }
#endif
        fNeedsStencilAttachmentBind[useMultisampleFBO] = false;
    }
}

◆ canAttemptStencilAttachment()

bool GrGLRenderTarget::canAttemptStencilAttachment ( bool useMultisampleFBO ) const

overridevirtual

Implements GrRenderTarget.

Reimplemented in GrGLTextureRenderTarget.

Definition at line 331 of file GrGLRenderTarget.cpp.

                                                                               {
    // This cap should have been handled at a higher level.
    SkASSERT(!this->getGpu()->getContext()->priv().caps()->avoidStencilBuffers());
    // Only modify the FBO's attachments if we have created the FBO. Public APIs do not currently
    // allow for borrowed FBO ownership, so we can safely assume that if an object is owned,
    // Skia created it.
    return this->fRTFBOOwnership == GrBackendObjectOwnership::kOwned ||
           // The dmsaa attachment is always owned and always supports adding stencil.
           (this->numSamples() == 1 && useMultisampleFBO);
}

◆ dumpMemoryStatistics()

void GrGLRenderTarget::dumpMemoryStatistics ( SkTraceMemoryDump * traceMemoryDump ) const

overridevirtual

Dumps memory usage information for this GrGpuResource to traceMemoryDump. Typically, subclasses should not need to override this, and should only need to override setMemoryBacking.

Reimplemented from GrGpuResource.

Reimplemented in GrGLTextureRenderTarget.

Definition at line 342 of file GrGLRenderTarget.cpp.

                                                                                    {
    // Don't check this->fRefsWrappedObjects, as we might be the base of a GrGLTextureRenderTarget
    // which is multiply inherited from both ourselves and a texture. In these cases, one part
    // (texture, rt) may be wrapped, while the other is owned by Skia.
    bool refsWrappedRenderTargetObjects =
            this->fRTFBOOwnership == GrBackendObjectOwnership::kBorrowed;
    if (refsWrappedRenderTargetObjects && !traceMemoryDump->shouldDumpWrappedObjects()) {
        return;
    }
 
    int numSamplesNotInTexture = fTotalMemorySamplesPerPixel;
    if (this->asTexture()) {
        --numSamplesNotInTexture;  // GrGLTexture::dumpMemoryStatistics accounts for 1 sample.
    }
    if (numSamplesNotInTexture >= 1) {
        size_t size = GrSurface::ComputeSize(this->backendFormat(),
                                             this->dimensions(),
                                             numSamplesNotInTexture,
                                             skgpu::Mipmapped::kNo);
 
        // Due to this resource having both a texture and a renderbuffer component, dump as
        // skia/gpu_resources/resource_#/renderbuffer
        SkString resourceName = this->getResourceName();
        resourceName.append("/renderbuffer");
 
        this->dumpMemoryStatisticsPriv(traceMemoryDump, resourceName, "RenderTarget", size);
 
        SkString renderbuffer_id;
        renderbuffer_id.appendU32(fMSColorRenderbufferID);
        traceMemoryDump->setMemoryBacking(resourceName.c_str(), "gl_renderbuffer",
                                          renderbuffer_id.c_str());
    }
}

◆ ensureDynamicMSAAAttachment()

bool GrGLRenderTarget::ensureDynamicMSAAAttachment ( )

Definition at line 157 of file GrGLRenderTarget.cpp.

                                                   {
    SkASSERT(this->numSamples() == 1);
    if (fMultisampleFBOID) {
        return true;
    }
    SkASSERT(!fDynamicMSAAAttachment);
 
    GrResourceProvider* resourceProvider = this->getContext()->priv().resourceProvider();
    const GrCaps& caps = *this->getGpu()->caps();
 
    int internalSampleCount = caps.internalMultisampleCount(this->backendFormat());
    if (internalSampleCount <= 1) {
        return false;
    }
 
    if (resourceProvider->caps()->msaaResolvesAutomatically() && this->asTexture()) {
        // We can use EXT_multisampled_render_to_texture for MSAA. We will configure the FBO as MSAA
        // or not during bindFBO().
        fMultisampleFBOID = fSingleSampleFBOID;
        return true;
    }
 
    GL_CALL(GenFramebuffers(1, &fMultisampleFBOID));
    if (!fMultisampleFBOID) {
        return false;
    }
 
    this->getGLGpu()->bindFramebuffer(GR_GL_FRAMEBUFFER, fMultisampleFBOID);
 
    fDynamicMSAAAttachment.reset(
            static_cast<GrGLAttachment*>(resourceProvider->getDiscardableMSAAAttachment(
                    this->dimensions(), this->backendFormat(), internalSampleCount,
                    GrProtected(this->isProtected()), GrMemoryless::kNo).release()));
    if (!fDynamicMSAAAttachment) {
        return false;
    }
 
    GL_CALL(FramebufferRenderbuffer(GR_GL_FRAMEBUFFER, GR_GL_COLOR_ATTACHMENT0, GR_GL_RENDERBUFFER,
                                    fDynamicMSAAAttachment->renderbufferID()));
    return true;
}

◆ format()

GrGLFormat GrGLRenderTarget::format ( ) const

inline

Definition at line 67 of file GrGLRenderTarget.h.

67{ return fRTFormat; }

◆ getBackendRenderTarget()

GrBackendRenderTarget GrGLRenderTarget::getBackendRenderTarget ( ) const

overridevirtual

Implements GrRenderTarget.

Definition at line 116 of file GrGLRenderTarget.cpp.

                                                                     {
    bool useMultisampleFBO = (this->numSamples() > 1);
    GrGLFramebufferInfo fbi;
    fbi.fFBOID = (useMultisampleFBO) ? fMultisampleFBOID : fSingleSampleFBOID;
    fbi.fFormat = GrGLFormatToEnum(this->format());
    fbi.fProtected = skgpu::Protected(this->isProtected());
    int numStencilBits = 0;
    if (GrAttachment* stencil = this->getStencilAttachment(useMultisampleFBO)) {
        numStencilBits = GrBackendFormatStencilBits(stencil->backendFormat());
    }
 
    return GrBackendRenderTargets::MakeGL(
            this->width(), this->height(), this->numSamples(), numStencilBits, fbi);
}

◆ glRTFBOIDis0()

bool GrSurface::glRTFBOIDis0 ( ) const

inline

Definition at line 117 of file GrSurface.h.

                              {
        return fSurfaceFlags & GrInternalSurfaceFlags::kGLRTFBOIDIs0;
    }

◆ hasDynamicMSAAAttachment()

bool GrGLRenderTarget::hasDynamicMSAAAttachment ( ) const

inline

Definition at line 69 of file GrGLRenderTarget.h.

69{ return SkToBool(fDynamicMSAAAttachment); }

SkToBool

static constexpr bool SkToBool(const T &x)

Definition: SkTo.h:35

◆ init()

void GrGLRenderTarget::init	(	GrGLFormat	format,
		const IDs &	idDesc
	)

protected

Definition at line 60 of file GrGLRenderTarget.cpp.

                                                                {
    fMultisampleFBOID = idDesc.fMultisampleFBOID;
    fSingleSampleFBOID = idDesc.fSingleSampleFBOID;
    fMSColorRenderbufferID = idDesc.fMSColorRenderbufferID;
    fRTFBOOwnership = idDesc.fRTFBOOwnership;
    fRTFormat = format;
    fTotalMemorySamplesPerPixel = idDesc.fTotalMemorySamplesPerPixel;
}

◆ isFBO0()

bool GrGLRenderTarget::isFBO0 ( bool multisample ) const

inline

Definition at line 49 of file GrGLRenderTarget.h.

                                        {
        return (multisample ? fMultisampleFBOID : fSingleSampleFBOID) == 0;
    }

◆ isMultisampledRenderToTexture()

bool GrGLRenderTarget::isMultisampledRenderToTexture ( ) const

inline

Definition at line 53 of file GrGLRenderTarget.h.

                                               {
        return fMultisampleFBOID != 0 && fMultisampleFBOID == fSingleSampleFBOID;
    }

◆ MakeWrapped()

sk_sp< GrGLRenderTarget > GrGLRenderTarget::MakeWrapped	(	GrGLGpu *	gpu,
		const SkISize &	dimensions,
		GrGLFormat	format,
		int	sampleCount,
		const IDs &	idDesc,
		int	stencilBits,
		skgpu::Protected	isProtected,
		std::string_view	label
	)

static

Definition at line 85 of file GrGLRenderTarget.cpp.

                                                                            {
    sk_sp<GrGLAttachment> sb;
    if (stencilBits) {
        // We pick a "fake" actual format that matches the number of stencil bits. When wrapping
        // an FBO with some number of stencil bits all we care about in the future is that we have
        // a format with the same number of stencil bits. We don't even directly use the format or
        // any other properties. Thus it is fine for us to just assign an arbitrary format that
        // matches the stencil bit count.
        GrGLFormat sFmt = stencil_bits_to_format(stencilBits);
 
        // We don't have the actual renderbufferID but we need to make an attachment for the stencil
        // so we just set it to an invalid value of 0 to make sure we don't explicitly use it or try
        // and delete it.
        sb = GrGLAttachment::MakeWrappedRenderBuffer(gpu,
                                                     /*renderbufferID=*/0,
                                                     dimensions,
                                                     GrAttachment::UsageFlags::kStencilAttachment,
                                                     sampleCount,
                                                     sFmt);
    }
    return sk_sp<GrGLRenderTarget>(new GrGLRenderTarget(
            gpu, dimensions, format, sampleCount, idDesc, std::move(sb), isProtected, label));
}

◆ mustRebind()

bool GrGLRenderTarget::mustRebind ( bool useMultisampleFBO ) const

inline

Definition at line 78 of file GrGLRenderTarget.h.

                                                  {
        return fNeedsStencilAttachmentBind[useMultisampleFBO];
    }

◆ onAbandon()

void GrGLRenderTarget::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 GrGpuResource.

Reimplemented in GrGLTextureRenderTarget.

Definition at line 319 of file GrGLRenderTarget.cpp.

                                 {
    fMultisampleFBOID       = 0;
    fSingleSampleFBOID      = 0;
    fMSColorRenderbufferID  = 0;
    INHERITED::onAbandon();
}

◆ onRelease()

void GrGLRenderTarget::onRelease ( )

overrideprotectedvirtual

Overridden to free GPU resources in the backend API.

Reimplemented from GrGpuResource.

Reimplemented in GrGLTextureRenderTarget.

Definition at line 300 of file GrGLRenderTarget.cpp.

                                 {
    if (GrBackendObjectOwnership::kBorrowed != fRTFBOOwnership) {
        GrGLGpu* gpu = this->getGLGpu();
        if (fSingleSampleFBOID) {
            gpu->deleteFramebuffer(fSingleSampleFBOID);
        }
        if (fMultisampleFBOID && fMultisampleFBOID != fSingleSampleFBOID) {
            gpu->deleteFramebuffer(fMultisampleFBOID);
        }
        if (fMSColorRenderbufferID) {
            GL_CALL(DeleteRenderbuffers(1, &fMSColorRenderbufferID));
        }
    }
    fMultisampleFBOID       = 0;
    fSingleSampleFBOID      = 0;
    fMSColorRenderbufferID  = 0;
    INHERITED::onRelease();
}

◆ totalMemorySamplesPerPixel()

int GrGLRenderTarget::totalMemorySamplesPerPixel ( ) const

inlineprotected

Definition at line 117 of file GrGLRenderTarget.h.

117{ return fTotalMemorySamplesPerPixel; }

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

third_party/skia/src/gpu/ganesh/gl/GrGLRenderTarget.h
third_party/skia/src/gpu/ganesh/gl/GrGLRenderTarget.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

◆ ResolveDirection

Constructor & Destructor Documentation

◆ GrGLRenderTarget()

Member Function Documentation

◆ alwaysClearStencil()

◆ backendFormat()

◆ bind()

◆ bindForPixelOps()

◆ bindForResolve()

◆ bindInternal()

◆ canAttemptStencilAttachment()

◆ dumpMemoryStatistics()

◆ ensureDynamicMSAAAttachment()

◆ format()

◆ getBackendRenderTarget()

◆ glRTFBOIDis0()

◆ hasDynamicMSAAAttachment()

◆ init()

◆ isFBO0()

◆ isMultisampledRenderToTexture()

◆ MakeWrapped()

◆ mustRebind()

◆ onAbandon()

◆ onRelease()

◆ totalMemorySamplesPerPixel()