GrSurfaceProxy Class Reference

#include <GrSurfaceProxy.h>

Inheritance diagram for GrSurfaceProxy:

Classes
struct	LazyCallbackResult
struct	LazySurfaceDesc
class	UniqueID

Public Types
enum class	ResolveFlags { kNone = 0 , kMSAA = 1 << 0 , kMipMaps = 1 << 1 }
enum class	LazyInstantiationKeyMode { kUnsynced , kSynced }
enum class	UseAllocator { kNo = false , kYes = true }
enum class	RectsMustMatch : bool { kNo = false , kYes = true }
using	LazyInstantiateCallback = std::function< LazyCallbackResult(GrResourceProvider *, const LazySurfaceDesc &)>

Public Member Functions
virtual	~GrSurfaceProxy ()
bool	isLazy () const
bool	isFullyLazy () const
SkISize	dimensions () const
int	width () const
int	height () const
SkISize	backingStoreDimensions () const
SkRect	getBoundsRect () const
bool	isFunctionallyExact () const
SkRect	backingStoreBoundsRect () const
SkIRect	backingStoreBoundsIRect () const
const GrBackendFormat &	backendFormat () const
bool	isFormatCompressed (const GrCaps *) const
UniqueID	uniqueID () const
UniqueID	underlyingUniqueID () const
virtual bool	instantiate (GrResourceProvider *)=0
void	deinstantiate ()
bool	canSkipResourceAllocator () const
virtual GrTextureProxy *	asTextureProxy ()
virtual const GrTextureProxy *	asTextureProxy () const
virtual GrRenderTargetProxy *	asRenderTargetProxy ()
virtual const GrRenderTargetProxy *	asRenderTargetProxy () const
virtual const skgpu::UniqueKey &	getUniqueKey () const
bool	isInstantiated () const
void	isUsedAsTaskTarget ()
int	getTaskTargetCount () const
GrSurface *	peekSurface () const
GrTexture *	peekTexture () const
GrRenderTarget *	peekRenderTarget () const
skgpu::Budgeted	isBudgeted () const
bool	readOnly () const
bool	framebufferOnly () const
bool	requiresManualMSAAResolve () const
size_t	gpuMemorySize () const
std::string_view	getLabel () const
GrSurfaceProxyPriv	priv ()
const GrSurfaceProxyPriv	priv () const
bool	isDDLTarget () const
GrProtected	isProtected () const
bool	isPromiseProxy ()
Public Member Functions inherited from SkNVRefCnt< GrSurfaceProxy >
	SkNVRefCnt ()
	~SkNVRefCnt ()
bool	unique () const
void	ref () const
void	unref () const
void	deref () const
bool	refCntGreaterThan (int32_t threadIsolatedTestCnt) const

Static Public Member Functions
static sk_sp< GrSurfaceProxy >	Copy (GrRecordingContext *, sk_sp< GrSurfaceProxy > src, GrSurfaceOrigin, skgpu::Mipmapped, SkIRect srcRect, SkBackingFit, skgpu::Budgeted, std::string_view label, RectsMustMatch=RectsMustMatch::kNo, sk_sp< GrRenderTask > *outTask=nullptr)
static sk_sp< GrSurfaceProxy >	Copy (GrRecordingContext *, sk_sp< GrSurfaceProxy > src, GrSurfaceOrigin, skgpu::Mipmapped, SkBackingFit, skgpu::Budgeted, std::string_view label, sk_sp< GrRenderTask > *outTask=nullptr)

Protected Member Functions
	GrSurfaceProxy (const GrBackendFormat &, SkISize, SkBackingFit, skgpu::Budgeted, GrProtected, GrInternalSurfaceFlags, UseAllocator, std::string_view label)
	GrSurfaceProxy (LazyInstantiateCallback &&, const GrBackendFormat &, SkISize, SkBackingFit, skgpu::Budgeted, GrProtected, GrInternalSurfaceFlags, UseAllocator, std::string_view label)
	GrSurfaceProxy (sk_sp< GrSurface >, SkBackingFit, UseAllocator)
bool	ignoredByResourceAllocator () const
void	setIgnoredByResourceAllocator ()
void	computeScratchKey (const GrCaps &, skgpu::ScratchKey *) const
virtual sk_sp< GrSurface >	createSurface (GrResourceProvider *) const =0
void	assign (sk_sp< GrSurface > surface)
sk_sp< GrSurface >	createSurfaceImpl (GrResourceProvider *, int sampleCnt, GrRenderable, skgpu::Mipmapped) const
void	setLazyDimensions (SkISize dimensions)
bool	instantiateImpl (GrResourceProvider *resourceProvider, int sampleCnt, GrRenderable, skgpu::Mipmapped, const skgpu::UniqueKey *)

Protected Attributes
sk_sp< GrSurface >	fTarget
GrInternalSurfaceFlags	fSurfaceFlags

Private Member Functions
	SkDEBUGCODE (void validateSurface(const GrSurface *);) SkDEBUGCODE(virtual void onValidateSurface(const GrSurface *)=0
	SkDEBUGCODE (size_t getRawGpuMemorySize_debugOnly() const { return fGpuMemorySize;}) virtual size_t onUninstantiatedGpuMemorySize() const =0
virtual LazySurfaceDesc	callbackDesc () const =0

Friends
class	GrSurfaceProxyPriv

Detailed Description

Definition at line 49 of file GrSurfaceProxy.h.

Member Typedef Documentation

LazyInstantiateCallback

using GrSurfaceProxy::LazyInstantiateCallback = std::function<LazyCallbackResult(GrResourceProvider*, const LazySurfaceDesc&)>

Definition at line 121 of file GrSurfaceProxy.h.

Member Enumeration Documentation

LazyInstantiationKeyMode

enum class GrSurfaceProxy::LazyInstantiationKeyMode

strong

Some lazy proxy callbacks want to set their own (or no key) on the GrSurfaces they return. Others want the GrSurface's key to be kept in sync with the proxy's key. This enum controls the key relationship between proxies and their targets.

Enumerator
kUnsynced	Don't key the GrSurface with the proxy's key. The lazy instantiation callback is free to return a GrSurface that already has a unique key unrelated to the proxy's key.
kSynced	Keep the GrSurface's unique key in sync with the proxy's unique key. The GrSurface returned from the lazy instantiation callback must not have a unique key or have the same same unique key as the proxy. If the proxy is later assigned a key it is in turn assigned to the GrSurface.

Definition at line 68 of file GrSurfaceProxy.h.

                                        {
        /**
         * Don't key the GrSurface with the proxy's key. The lazy instantiation callback is free to
         * return a GrSurface that already has a unique key unrelated to the proxy's key.
         */
        kUnsynced,
        /**
         * Keep the GrSurface's unique key in sync with the proxy's unique key. The GrSurface
         * returned from the lazy instantiation callback must not have a unique key or have the same
         * same unique key as the proxy. If the proxy is later assigned a key it is in turn assigned
         * to the GrSurface.
         */
        kSynced
    };

RectsMustMatch

enum class GrSurfaceProxy::RectsMustMatch : bool

strong

Enumerator
kNo
kYes

Definition at line 324 of file GrSurfaceProxy.h.

                              : bool {
        kNo = false,
        kYes = true
    };

ResolveFlags

enum class GrSurfaceProxy::ResolveFlags

strong

Indicates "resolutions" that need to be done on a surface before its pixels can be accessed. If both types of resolve are requested, the MSAA resolve will happen first.

Enumerator
kNone
kMSAA
kMipMaps

Definition at line 57 of file GrSurfaceProxy.h.

                            {
        kNone = 0,
        kMSAA = 1 << 0,  // Blit and resolve an internal MSAA render buffer into the texture.
        kMipMaps = 1 << 1,  // Regenerate all mipmap levels.
    };

UseAllocator

enum class GrSurfaceProxy::UseAllocator

strong

Enumerator
kNo	This proxy will be instantiated outside the allocator (e.g. for proxies that are instantiated in on-flush callbacks).
kYes	GrResourceAllocator should instantiate this proxy.

Definition at line 124 of file GrSurfaceProxy.h.

                            {
        /**
         * This proxy will be instantiated outside the allocator (e.g. for proxies that are
         * instantiated in on-flush callbacks).
         */
        kNo = false,
        /**
         * GrResourceAllocator should instantiate this proxy.
         */
        kYes = true,
    };

Constructor & Destructor Documentation

~GrSurfaceProxy()

GrSurfaceProxy::~GrSurfaceProxy ( )

virtual

Definition at line 123 of file GrSurfaceProxy.cpp.

                                {
}

GrSurfaceProxy() [1/3]

GrSurfaceProxy::GrSurfaceProxy ( const GrBackendFormat &  format, SkISize  dimensions, SkBackingFit  fit, skgpu::Budgeted  budgeted, GrProtected  isProtected, GrInternalSurfaceFlags  surfaceFlags, UseAllocator  useAllocator, std::string_view  label  )

protected

Definition at line 60 of file GrSurfaceProxy.cpp.

        : fSurfaceFlags(surfaceFlags)
        , fFormat(format)
        , fDimensions(dimensions)
        , fFit(fit)
        , fBudgeted(budgeted)
        , fUseAllocator(useAllocator)
        , fIsProtected(isProtected)
        , fLabel(label) {
    SkASSERT(fFormat.isValid());
    SkASSERT(is_valid_non_lazy(dimensions));
}

GrSurfaceProxy() [2/3]

GrSurfaceProxy::GrSurfaceProxy ( LazyInstantiateCallback &&  callback, const GrBackendFormat &  format, SkISize  dimensions, SkBackingFit  fit, skgpu::Budgeted  budgeted, GrProtected  isProtected, GrInternalSurfaceFlags  surfaceFlags, UseAllocator  useAllocator, std::string_view  label  )

protected

Definition at line 81 of file GrSurfaceProxy.cpp.

        : fSurfaceFlags(surfaceFlags)
        , fFormat(format)
        , fDimensions(dimensions)
        , fFit(fit)
        , fBudgeted(budgeted)
        , fUseAllocator(useAllocator)
        , fLazyInstantiateCallback(std::move(callback))
        , fIsProtected(isProtected)
        , fLabel(label) {
    SkASSERT(fFormat.isValid());
    SkASSERT(fLazyInstantiateCallback);
    SkASSERT(is_valid_lazy(dimensions, fit));
}

GrSurfaceProxy() [3/3]

GrSurfaceProxy::GrSurfaceProxy ( sk_sp< GrSurface >  surface, SkBackingFit  fit, UseAllocator  useAllocator  )

protected

Definition at line 105 of file GrSurfaceProxy.cpp.

        : fTarget(std::move(surface))
        , fSurfaceFlags(fTarget->flags())
        , fFormat(fTarget->backendFormat())
        , fDimensions(fTarget->dimensions())
        , fFit(fit)
        , fBudgeted(fTarget->resourcePriv().budgetedType() == GrBudgetedType::kBudgeted
                            ? skgpu::Budgeted::kYes
                            : skgpu::Budgeted::kNo)
        , fUseAllocator(useAllocator)
        , fUniqueID(fTarget->uniqueID())  // Note: converting from unique resource ID to a proxy ID!
        , fIsProtected(fTarget->isProtected() ? GrProtected::kYes : GrProtected::kNo)
        , fLabel(fTarget->getLabel()) {
    SkASSERT(fFormat.isValid());
}

Member Function Documentation

asRenderTargetProxy() [1/2]

virtual GrRenderTargetProxy * GrSurfaceProxy::asRenderTargetProxy ( )

inlinevirtual

Returns

the render target proxy associated with the surface proxy, may be NULL.

Reimplemented in GrRenderTargetProxy.

Definition at line 250 of file GrSurfaceProxy.h.

{ return nullptr; }

asRenderTargetProxy() [2/2]

virtual const GrRenderTargetProxy * GrSurfaceProxy::asRenderTargetProxy ( ) const

inlinevirtual

Reimplemented in GrRenderTargetProxy.

Definition at line 251 of file GrSurfaceProxy.h.

{ return nullptr; }

assign()

void GrSurfaceProxy::assign ( sk_sp< GrSurface >  surface )

protected

Definition at line 176 of file GrSurfaceProxy.cpp.

                                                    {
    SkASSERT(!fTarget && surface);
 
    SkDEBUGCODE(this->validateSurface(surface.get());)
 
    fTarget = std::move(surface);
 
#ifdef SK_DEBUG
    if (this->asRenderTargetProxy()) {
        SkASSERT(fTarget->asRenderTarget());
    }
 
    // In order to give DDL users some flexibility in the destination of there DDLs,
    // a DDL's target proxy can be more conservative (and thus require less memory)
    // than the actual GrSurface used to fulfill it.
    if (!this->isDDLTarget() && kInvalidGpuMemorySize != this->getRawGpuMemorySize_debugOnly()) {
        // TODO(11373): Can this check be exact?
        SkASSERT(fTarget->gpuMemorySize() <= this->getRawGpuMemorySize_debugOnly());
    }
#endif
}

asTextureProxy() [1/2]

virtual GrTextureProxy * GrSurfaceProxy::asTextureProxy ( )

inlinevirtual

Returns

the texture proxy associated with the surface proxy, may be NULL.

Reimplemented in GrTextureProxy.

Definition at line 244 of file GrSurfaceProxy.h.

{ return nullptr; }

asTextureProxy() [2/2]

virtual const GrTextureProxy * GrSurfaceProxy::asTextureProxy ( ) const

inlinevirtual

Reimplemented in GrTextureProxy.

Definition at line 245 of file GrSurfaceProxy.h.

{ return nullptr; }

backendFormat()

const GrBackendFormat & GrSurfaceProxy::backendFormat ( ) const

inline

Definition at line 173 of file GrSurfaceProxy.h.

{ return fFormat; }

backingStoreBoundsIRect()

SkIRect GrSurfaceProxy::backingStoreBoundsIRect ( ) const

inline

Definition at line 169 of file GrSurfaceProxy.h.

                                            {
        return SkIRect::MakeSize(this->backingStoreDimensions());
    }

backingStoreBoundsRect()

SkRect GrSurfaceProxy::backingStoreBoundsRect ( ) const

inline

Helper that gets the dimensions the backing GrSurface will have as a bounding rectangle.

Definition at line 165 of file GrSurfaceProxy.h.

                                          {
        return SkRect::Make(this->backingStoreDimensions());
    }

backingStoreDimensions()

SkISize GrSurfaceProxy::backingStoreDimensions

(

)

const

Definition at line 252 of file GrSurfaceProxy.cpp.

                                                     {
    SkASSERT(!this->isFullyLazy());
    if (fTarget) {
        return fTarget->dimensions();
    }
 
    if (SkBackingFit::kExact == fFit) {
        return fDimensions;
    }
    return skgpu::GetApproxSize(fDimensions);
}

callbackDesc()

virtual LazySurfaceDesc GrSurfaceProxy::callbackDesc ( ) const

privatepure virtual

canSkipResourceAllocator()

bool GrSurfaceProxy::canSkipResourceAllocator

(

)

const

Proxies that are already instantiated and whose backing surface cannot be recycled to instantiate other proxies do not need to be considered by GrResourceAllocator.

Definition at line 161 of file GrSurfaceProxy.cpp.

                                                    {
    if (fUseAllocator == UseAllocator::kNo) {
        // Usually an atlas or onFlush proxy
        return true;
    }
 
    auto peek = this->peekSurface();
    if (!peek) {
        return false;
    }
    // If this resource is already allocated and not recyclable then the resource allocator does
    // not need to do anything with it.
    return !peek->resourcePriv().getScratchKey().isValid();
}

computeScratchKey()

void GrSurfaceProxy::computeScratchKey ( const GrCaps &  caps, skgpu::ScratchKey *  key  ) const

protected

Definition at line 233 of file GrSurfaceProxy.cpp.

                                                                                     {
    SkASSERT(!this->isFullyLazy());
    GrRenderable renderable = GrRenderable::kNo;
    int sampleCount = 1;
    if (const auto* rtp = this->asRenderTargetProxy()) {
        renderable = GrRenderable::kYes;
        sampleCount = rtp->numSamples();
    }
 
    const GrTextureProxy* tp = this->asTextureProxy();
    skgpu::Mipmapped mipmapped = skgpu::Mipmapped::kNo;
    if (tp) {
        mipmapped = tp->mipmapped();
    }
 
    GrTexture::ComputeScratchKey(caps, this->backendFormat(), this->backingStoreDimensions(),
                                 renderable, sampleCount, mipmapped, fIsProtected, key);
}

Copy() [1/2]

sk_sp< GrSurfaceProxy > GrSurfaceProxy::Copy ( GrRecordingContext *  context, sk_sp< GrSurfaceProxy >  src, GrSurfaceOrigin  origin, skgpu::Mipmapped  mipmapped, SkBackingFit  fit, skgpu::Budgeted  budgeted, std::string_view  label, sk_sp< GrRenderTask > *  outTask = nullptr  )

static

Definition at line 359 of file GrSurfaceProxy.cpp.

                                                                         {
    SkASSERT(!src->isFullyLazy());
    auto rect = SkIRect::MakeSize(src->dimensions());
    return Copy(context,
                std::move(src),
                origin,
                mipmapped,
                rect,
                fit,
                budgeted,
                label,
                RectsMustMatch::kNo,
                outTask);
}

Copy() [2/2]

sk_sp< GrSurfaceProxy > GrSurfaceProxy::Copy ( GrRecordingContext *  rContext, sk_sp< GrSurfaceProxy >  src, GrSurfaceOrigin  origin, skgpu::Mipmapped  mipmapped, SkIRect  srcRect, SkBackingFit  fit, skgpu::Budgeted  budgeted, std::string_view  label, RectsMustMatch  rectsMustMatch = RectsMustMatch::kNo, sk_sp< GrRenderTask > *  outTask = nullptr  )

static

Definition at line 282 of file GrSurfaceProxy.cpp.

                                                                         {
    SkASSERT(!src->isFullyLazy());
    int width;
    int height;
 
    SkIPoint dstPoint;
    if (rectsMustMatch == RectsMustMatch::kYes) {
        width = src->width();
        height = src->height();
        dstPoint = {srcRect.fLeft, srcRect.fTop};
    } else {
        width = srcRect.width();
        height = srcRect.height();
        dstPoint = {0, 0};
    }
 
    if (!srcRect.intersect(SkIRect::MakeSize(src->dimensions()))) {
        return {};
    }
    auto format = src->backendFormat().makeTexture2D();
    SkASSERT(format.isValid());
 
    if (src->backendFormat().textureType() != GrTextureType::kExternal) {
        GrImageInfo info(GrColorType::kUnknown, kUnknown_SkAlphaType, nullptr, {width, height});
        auto dstContext = rContext->priv().makeSC(info,
                                                  format,
                                                  label,
                                                  fit,
                                                  origin,
                                                  GrRenderable::kNo,
                                                  1,
                                                  mipmapped,
                                                  src->isProtected(),
                                                  budgeted);
        sk_sp<GrRenderTask> copyTask;
        if (dstContext && (copyTask = dstContext->copy(src, srcRect, dstPoint))) {
            if (outTask) {
                *outTask = std::move(copyTask);
            }
            return dstContext->asSurfaceProxyRef();
        }
    }
    if (src->asTextureProxy()) {
        auto dstContext = rContext->priv().makeSFC(kUnknown_SkAlphaType,
                                                   nullptr,
                                                   {width, height},
                                                   fit,
                                                   format,
                                                   1,
                                                   mipmapped,
                                                   src->isProtected(),
                                                   skgpu::Swizzle::RGBA(),
                                                   skgpu::Swizzle::RGBA(),
                                                   origin,
                                                   budgeted,
                                                   label);
        GrSurfaceProxyView view(std::move(src), origin, skgpu::Swizzle::RGBA());
        if (dstContext && dstContext->blitTexture(std::move(view), srcRect, dstPoint)) {
            if (outTask) {
                *outTask = dstContext->refRenderTask();
            }
            return dstContext->asSurfaceProxyRef();
        }
    }
    // Can't use backend copies or draws.
    return nullptr;
}

createSurface()

virtual sk_sp< GrSurface > GrSurfaceProxy::createSurface ( GrResourceProvider *  ) const

protectedpure virtual

Implemented in GrRenderTargetProxy, GrTextureProxy, and GrMockSurfaceProxy.

createSurfaceImpl()

sk_sp< GrSurface > GrSurfaceProxy::createSurfaceImpl ( GrResourceProvider *  resourceProvider, int  sampleCnt, GrRenderable  renderable, skgpu::Mipmapped  mipmapped  ) const

protected

Definition at line 126 of file GrSurfaceProxy.cpp.

                                                                                   {
    SkASSERT(mipmapped == skgpu::Mipmapped::kNo || fFit == SkBackingFit::kExact);
    SkASSERT(!this->isLazy());
    SkASSERT(!fTarget);
 
    sk_sp<GrSurface> surface;
    if (SkBackingFit::kApprox == fFit) {
        surface = resourceProvider->createApproxTexture(fDimensions,
                                                        fFormat,
                                                        fFormat.textureType(),
                                                        renderable,
                                                        sampleCnt,
                                                        fIsProtected,
                                                        fLabel);
    } else {
        surface = resourceProvider->createTexture(fDimensions,
                                                  fFormat,
                                                  fFormat.textureType(),
                                                  renderable,
                                                  sampleCnt,
                                                  mipmapped,
                                                  fBudgeted,
                                                  fIsProtected,
                                                  fLabel);
    }
    if (!surface) {
        return nullptr;
    }
 
    return surface;
}

deinstantiate()

void GrSurfaceProxy::deinstantiate

(

)

Definition at line 228 of file GrSurfaceProxy.cpp.

                                   {
    SkASSERT(this->isInstantiated());
    fTarget = nullptr;
}

dimensions()

SkISize GrSurfaceProxy::dimensions ( ) const

inline

Definition at line 145 of file GrSurfaceProxy.h.

                               {
        SkASSERT(!this->isFullyLazy());
        return fDimensions;
    }

framebufferOnly()

bool GrSurfaceProxy::framebufferOnly ( ) const

inline

Definition at line 292 of file GrSurfaceProxy.h.

                                 {
        return fSurfaceFlags & GrInternalSurfaceFlags::kFramebufferOnly;
    }

getBoundsRect()

SkRect GrSurfaceProxy::getBoundsRect ( ) const

inline

Helper that gets the width and height of the proxy as a bounding rectangle.

Definition at line 157 of file GrSurfaceProxy.h.

{ return SkRect::Make(this->dimensions()); }

getLabel()

std::string_view GrSurfaceProxy::getLabel ( ) const

inline

Definition at line 322 of file GrSurfaceProxy.h.

{ return fLabel; }

getTaskTargetCount()

int GrSurfaceProxy::getTaskTargetCount ( ) const

inline

How many render tasks has this proxy been the target of?

Definition at line 266 of file GrSurfaceProxy.h.

{ return fTaskTargetCount; }

getUniqueKey()

virtual const skgpu::UniqueKey & GrSurfaceProxy::getUniqueKey ( ) const

inlinevirtual

Returns

The unique key for this proxy. May be invalid.

Reimplemented in GrTextureProxy.

Definition at line 254 of file GrSurfaceProxy.h.

                                                       {
        // Base class never has a valid unique key.
        static const skgpu::UniqueKey kInvalidKey;
        return kInvalidKey;
    }

gpuMemorySize()

size_t GrSurfaceProxy::gpuMemorySize ( ) const

inline

Retrieves the amount of GPU memory that will be or currently is used by this resource in bytes. It is approximate since we aren't aware of additional padding or copies made by the driver.

Returns

the amount of GPU memory used in bytes

Definition at line 313 of file GrSurfaceProxy.h.

                                 {
        SkASSERT(!this->isFullyLazy());
        if (kInvalidGpuMemorySize == fGpuMemorySize) {
            fGpuMemorySize = this->onUninstantiatedGpuMemorySize();
            SkASSERT(kInvalidGpuMemorySize != fGpuMemorySize);
        }
        return fGpuMemorySize;
    }

height()

int GrSurfaceProxy::height ( ) const

inline

Definition at line 150 of file GrSurfaceProxy.h.

{ return this->dimensions().height(); }

ignoredByResourceAllocator()

bool GrSurfaceProxy::ignoredByResourceAllocator ( ) const

inlineprotected

Definition at line 415 of file GrSurfaceProxy.h.

{ return fIgnoredByResourceAllocator; }

instantiate()

virtual bool GrSurfaceProxy::instantiate ( GrResourceProvider *  )

pure virtual

Implemented in GrRenderTargetProxy, GrTextureProxy, and GrMockSurfaceProxy.

instantiateImpl()

bool GrSurfaceProxy::instantiateImpl ( GrResourceProvider *  resourceProvider, int  sampleCnt, GrRenderable  renderable, skgpu::Mipmapped  mipmapped, const skgpu::UniqueKey *  uniqueKey  )

protected

Definition at line 198 of file GrSurfaceProxy.cpp.

                                                                      {
    SkASSERT(!this->isLazy());
    if (fTarget) {
        if (uniqueKey && uniqueKey->isValid()) {
            SkASSERT(fTarget->getUniqueKey().isValid() && fTarget->getUniqueKey() == *uniqueKey);
        }
        return true;
    }
 
    sk_sp<GrSurface> surface = this->createSurfaceImpl(resourceProvider, sampleCnt, renderable,
                                                       mipmapped);
    if (!surface) {
        return false;
    }
 
    // If there was an invalidation message pending for this key, we might have just processed it,
    // causing the key (stored on this proxy) to become invalid.
    if (uniqueKey && uniqueKey->isValid()) {
        resourceProvider->assignUniqueKeyToResource(*uniqueKey, surface.get());
    }
 
    this->assign(std::move(surface));
 
    return true;
}

isBudgeted()

skgpu::Budgeted GrSurfaceProxy::isBudgeted ( ) const

inline

Does the resource count against the resource budget?

Definition at line 284 of file GrSurfaceProxy.h.

{ return fBudgeted; }

isDDLTarget()

bool GrSurfaceProxy::isDDLTarget ( ) const

inline

Definition at line 379 of file GrSurfaceProxy.h.

{ return fIsDDLTarget; }

isFormatCompressed()

bool GrSurfaceProxy::isFormatCompressed

(

const GrCaps *

caps

)

const

Definition at line 270 of file GrSurfaceProxy.cpp.

                                                                {
    return caps->isFormatCompressed(this->backendFormat());
}

isFullyLazy()

bool GrSurfaceProxy::isFullyLazy ( ) const

inline

Definition at line 138 of file GrSurfaceProxy.h.

                             {
        bool result = fDimensions.width() < 0;
        SkASSERT(result == (fDimensions.height() < 0));
        SkASSERT(!result || this->isLazy());
        return result;
    }

isFunctionallyExact()

bool GrSurfaceProxy::isFunctionallyExact

(

)

const

Definition at line 264 of file GrSurfaceProxy.cpp.

                                               {
    SkASSERT(!this->isFullyLazy());
    return fFit == SkBackingFit::kExact ||
           fDimensions == skgpu::GetApproxSize(fDimensions);
}

isInstantiated()

bool GrSurfaceProxy::isInstantiated ( ) const

inline

Definition at line 260 of file GrSurfaceProxy.h.

{ return SkToBool(fTarget); }

isLazy()

bool GrSurfaceProxy::isLazy ( ) const

inline

Definition at line 136 of file GrSurfaceProxy.h.

{ return !this->isInstantiated() && SkToBool(fLazyInstantiateCallback); }

isPromiseProxy()

bool GrSurfaceProxy::isPromiseProxy ( )

inline

Definition at line 383 of file GrSurfaceProxy.h.

{ return fIsPromiseProxy; }

isProtected()

GrProtected GrSurfaceProxy::isProtected ( ) const

inline

Definition at line 381 of file GrSurfaceProxy.h.

{ return fIsProtected; }

isUsedAsTaskTarget()

void GrSurfaceProxy::isUsedAsTaskTarget ( )

inline

Called when this task becomes a target of a GrRenderTask.

Definition at line 263 of file GrSurfaceProxy.h.

{ ++fTaskTargetCount; }

peekRenderTarget()

GrRenderTarget * GrSurfaceProxy::peekRenderTarget ( ) const

inline

Definition at line 277 of file GrSurfaceProxy.h.

                                             {
        return fTarget ? fTarget->asRenderTarget() : nullptr;
    }

peekSurface()

GrSurface * GrSurfaceProxy::peekSurface ( ) const

inline

Definition at line 269 of file GrSurfaceProxy.h.

{ return fTarget.get(); }

peekTexture()

GrTexture * GrSurfaceProxy::peekTexture ( ) const

inline

Definition at line 273 of file GrSurfaceProxy.h.

{ return fTarget ? fTarget->asTexture() : nullptr; }

priv() [1/2]

GrSurfaceProxyPriv GrSurfaceProxy::priv ( )

inline

Definition at line 62 of file GrSurfaceProxyPriv.h.

{ return GrSurfaceProxyPriv(this); }

priv() [2/2]

const GrSurfaceProxyPriv GrSurfaceProxy::priv ( ) const

inline

Definition at line 64 of file GrSurfaceProxyPriv.h.

                                                            {  // NOLINT(readability-const-return-type)
    return GrSurfaceProxyPriv(const_cast<GrSurfaceProxy*>(this));
}

readOnly()

bool GrSurfaceProxy::readOnly ( ) const

inline

The pixel values of this proxy's surface cannot be modified (e.g. doesn't support write pixels or MIP map level regen). Read-only proxies also bypass interval tracking and assignment in GrResourceAllocator.

Definition at line 291 of file GrSurfaceProxy.h.

{ return fSurfaceFlags & GrInternalSurfaceFlags::kReadOnly; }

requiresManualMSAAResolve()

bool GrSurfaceProxy::requiresManualMSAAResolve ( ) const

inline

This means surface is a multisampled render target, and internally holds a non-msaa texture for resolving into. The render target resolves itself by blitting into this internal texture. (asTexture() might or might not return the internal texture, but if it does, we always resolve the render target before accessing this texture's data.)

Definition at line 302 of file GrSurfaceProxy.h.

                                           {
        return fSurfaceFlags & GrInternalSurfaceFlags::kRequiresManualMSAAResolve;
    }

setIgnoredByResourceAllocator()

void GrSurfaceProxy::setIgnoredByResourceAllocator ( )

inlineprotected

Definition at line 416 of file GrSurfaceProxy.h.

{ fIgnoredByResourceAllocator = true; }

setLazyDimensions()

void GrSurfaceProxy::setLazyDimensions ( SkISize  dimensions )

inlineprotected

Definition at line 432 of file GrSurfaceProxy.h.

                                               {
        SkASSERT(this->isFullyLazy());
        SkASSERT(!dimensions.isEmpty());
        fDimensions = dimensions;
    }

SkDEBUGCODE() [1/2]

GrSurfaceProxy::SkDEBUGCODE ( size_t getRawGpuMemorySize_debugOnly() const { return fGpuMemorySize;}  ) const

privatepure virtual

SkDEBUGCODE() [2/2]

GrSurfaceProxy::SkDEBUGCODE ( void validateSurface(const GrSurface *);  ) const

privatepure virtual

underlyingUniqueID()

UniqueID GrSurfaceProxy::underlyingUniqueID ( ) const

inline

Definition at line 223 of file GrSurfaceProxy.h.

                                        {
        if (fTarget) {
            return UniqueID(fTarget->uniqueID());
        }
 
        return fUniqueID;
    }

uniqueID()

UniqueID GrSurfaceProxy::uniqueID ( ) const

inline

Definition at line 221 of file GrSurfaceProxy.h.

{ return fUniqueID; }

width()

int GrSurfaceProxy::width ( ) const

inline

Definition at line 149 of file GrSurfaceProxy.h.

{ return this->dimensions().width(); }

Friends And Related Function Documentation

GrSurfaceProxyPriv

friend class GrSurfaceProxyPriv

friend

Definition at line 412 of file GrSurfaceProxy.h.

Member Data Documentation

fSurfaceFlags

GrInternalSurfaceFlags GrSurfaceProxy::fSurfaceFlags

protected

Definition at line 454 of file GrSurfaceProxy.h.

fTarget

sk_sp<GrSurface> GrSurfaceProxy::fTarget

protected

Definition at line 446 of file GrSurfaceProxy.h.

---

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

• third_party/skia/src/gpu/ganesh/GrSurfaceProxy.h
• third_party/skia/src/gpu/ganesh/GrSurfaceProxy.cpp
• third_party/skia/src/gpu/ganesh/GrSurfaceProxyPriv.h