#include <GrTextureProxy.h>

Inheritance diagram for GrTextureProxy:

Classes
class	CacheAccess

Public Member Functions
GrTextureProxy *	asTextureProxy () override

const GrTextureProxy *	asTextureProxy () const override

bool	instantiate (GrResourceProvider *) override

skgpu::Mipmapped	mipmapped () const

bool	mipmapsAreDirty () const

void	markMipmapsDirty ()

void	markMipmapsClean ()

skgpu::Mipmapped	proxyMipmapped () const

GrTextureType	textureType () const

bool	hasRestrictedSampling () const

const skgpu::UniqueKey &	getUniqueKey () const override

CacheAccess	cacheAccess ()

const CacheAccess	cacheAccess () const

GrTextureProxyPriv	texPriv ()

const GrTextureProxyPriv	texPriv () const

	GrTextureProxy (const GrBackendFormat &, SkISize, skgpu::Mipmapped, GrMipmapStatus, SkBackingFit, skgpu::Budgeted, skgpu::Protected, GrInternalSurfaceFlags, UseAllocator, GrDDLProvider creatingProvider, std::string_view label)

	GrTextureProxy (LazyInstantiateCallback &&, const GrBackendFormat &, SkISize, skgpu::Mipmapped, GrMipmapStatus, SkBackingFit, skgpu::Budgeted, skgpu::Protected, GrInternalSurfaceFlags, UseAllocator, GrDDLProvider creatingProvider, std::string_view label)

	GrTextureProxy (sk_sp< GrSurface >, UseAllocator, GrDDLProvider creatingProvider)

	~GrTextureProxy () override

sk_sp< GrSurface >	createSurface (GrResourceProvider *) const override

void	setTargetKeySync (bool sync)

Public Member Functions inherited from GrSurfaceProxy
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 bool	ProxiesAreCompatibleAsDynamicState (const GrSurfaceProxy first, const GrSurfaceProxy second)

Static Public Member Functions inherited from GrSurfaceProxy
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)

Friends
class(GrDDLProvider creatingProvider() const { return fCreatingProvider;}) protected	GrProxyProvider

class	GrTextureProxyPriv

class	GrSurfaceProxyPriv

Additional Inherited Members
Public Types inherited from GrSurfaceProxy
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 &)>

Protected Member Functions inherited from GrSurfaceProxy
	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 inherited from GrSurfaceProxy
sk_sp< GrSurface >	fTarget

GrInternalSurfaceFlags	fSurfaceFlags

Detailed Description

Definition at line 34 of file GrTextureProxy.h.

Constructor & Destructor Documentation

◆ GrTextureProxy() [1/3]

GrTextureProxy::GrTextureProxy	(	const GrBackendFormat &	format,
		SkISize	dimensions,
		skgpu::Mipmapped	mipmapped,
		GrMipmapStatus	mipmapStatus,
		SkBackingFit	fit,
		skgpu::Budgeted	budgeted,
		skgpu::Protected	isProtected,
		GrInternalSurfaceFlags	surfaceFlags,
		UseAllocator	useAllocator,
		GrDDLProvider	creatingProvider,
		std::string_view	label
	)

Definition at line 30 of file GrTextureProxy.cpp.

        : INHERITED(
                  format, dimensions, fit, budgeted, isProtected, surfaceFlags, useAllocator, label)
        , fMipmapped(mipmapped)
        , fMipmapStatus(mipmapStatus) SkDEBUGCODE(, fInitialMipmapStatus(fMipmapStatus))
        , fCreatingProvider(creatingProvider)
        , fProxyProvider(nullptr)
        , fDeferredUploader(nullptr) {
    SkASSERT(!(fSurfaceFlags & GrInternalSurfaceFlags::kFramebufferOnly));
    if (this->textureType() == GrTextureType::kExternal) {
        fSurfaceFlags |= GrInternalSurfaceFlags::kReadOnly;
    }
}

◆ GrTextureProxy() [2/3]

GrTextureProxy::GrTextureProxy	(	LazyInstantiateCallback &&	callback,
		const GrBackendFormat &	format,
		SkISize	dimensions,
		skgpu::Mipmapped	mipmapped,
		GrMipmapStatus	mipmapStatus,
		SkBackingFit	fit,
		skgpu::Budgeted	budgeted,
		skgpu::Protected	isProtected,
		GrInternalSurfaceFlags	surfaceFlags,
		UseAllocator	useAllocator,
		GrDDLProvider	creatingProvider,
		std::string_view	label
	)

Definition at line 55 of file GrTextureProxy.cpp.

        : INHERITED(std::move(callback),
                    format,
                    dimensions,
                    fit,
                    budgeted,
                    isProtected,
                    surfaceFlags,
                    useAllocator,
                    label)
        , fMipmapped(mipmapped)
        , fMipmapStatus(mipmapStatus) SkDEBUGCODE(, fInitialMipmapStatus(fMipmapStatus))
        , fCreatingProvider(creatingProvider)
        , fProxyProvider(nullptr)
        , fDeferredUploader(nullptr) {
    SkASSERT(!(fSurfaceFlags & GrInternalSurfaceFlags::kFramebufferOnly));
    if (this->textureType() == GrTextureType::kExternal) {
        fSurfaceFlags |= GrInternalSurfaceFlags::kReadOnly;
    }
}

◆ GrTextureProxy() [3/3]

GrTextureProxy::GrTextureProxy	(	sk_sp< GrSurface >	surf,
		UseAllocator	useAllocator,
		GrDDLProvider	creatingProvider
	)

Definition at line 88 of file GrTextureProxy.cpp.

        : INHERITED(std::move(surf), SkBackingFit::kExact, useAllocator)
        , fMipmapped(fTarget->asTexture()->mipmapped())
        , fMipmapStatus(fTarget->asTexture()->mipmapStatus())
        SkDEBUGCODE(, fInitialMipmapStatus(fMipmapStatus))
        , fCreatingProvider(creatingProvider)
        , fProxyProvider(nullptr)
        , fDeferredUploader(nullptr) {
    if (fTarget->getUniqueKey().isValid()) {
        fProxyProvider = fTarget->asTexture()->getContext()->priv().proxyProvider();
        fProxyProvider->adoptUniqueKeyFromSurface(this, fTarget.get());
    }
    if (this->textureType() == GrTextureType::kExternal) {
        fSurfaceFlags |= GrInternalSurfaceFlags::kReadOnly;
    }
}

◆ ~GrTextureProxy()

GrTextureProxy::~GrTextureProxy ( )

override

Definition at line 107 of file GrTextureProxy.cpp.

                                {
    // Due to the order of cleanup the GrSurface this proxy may have wrapped may have gone away
    // at this point. Zero out the pointer so the cache invalidation code doesn't try to use it.
    fTarget = nullptr;
 
    // In DDL-mode, uniquely keyed proxies keep their key even after their originating
    // proxy provider has gone away. In that case there is noone to send the invalid key
    // message to (Note: in this case we don't want to remove its cached resource).
    if (fUniqueKey.isValid() && fProxyProvider) {
        fProxyProvider->processInvalidUniqueKey(fUniqueKey, this,
                                                GrProxyProvider::InvalidateGPUResource::kNo);
    } else {
        SkASSERT(!fProxyProvider);
    }
}

Member Function Documentation

◆ asTextureProxy() [1/2]

const GrTextureProxy * GrTextureProxy::asTextureProxy ( ) const

inlineoverridevirtual

Reimplemented from GrSurfaceProxy.

Definition at line 37 of file GrTextureProxy.h.

37{ return this; }

◆ asTextureProxy() [2/2]

GrTextureProxy * GrTextureProxy::asTextureProxy ( )

inlineoverridevirtual

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

Reimplemented from GrSurfaceProxy.

Definition at line 36 of file GrTextureProxy.h.

36{ return this; }

◆ cacheAccess() [1/2]

GrTextureProxy::CacheAccess GrTextureProxy::cacheAccess ( )

inline

Definition at line 39 of file GrTextureProxyCacheAccess.h.

39{ return CacheAccess(this); }

◆ cacheAccess() [2/2]

const GrTextureProxy::CacheAccess GrTextureProxy::cacheAccess ( ) const

inline

Definition at line 41 of file GrTextureProxyCacheAccess.h.

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

◆ createSurface()

sk_sp< GrSurface > GrTextureProxy::createSurface ( GrResourceProvider * resourceProvider ) const

overridevirtual

Implements GrSurfaceProxy.

Definition at line 137 of file GrTextureProxy.cpp.

                                                                                         {
    sk_sp<GrSurface> surface = this->createSurfaceImpl(resourceProvider, 1, GrRenderable::kNo,
                                                       fMipmapped);
    if (!surface) {
        return nullptr;
    }
 
    SkASSERT(!surface->asRenderTarget());
    SkASSERT(surface->asTexture());
    return surface;
}

◆ getUniqueKey()

const skgpu::UniqueKey & GrTextureProxy::getUniqueKey ( ) const

inlineoverridevirtual

Return the texture proxy's unique key. It will be invalid if the proxy doesn't have one.

Reimplemented from GrSurfaceProxy.

Definition at line 84 of file GrTextureProxy.h.

                                                        {
#ifdef SK_DEBUG
        if (this->isInstantiated() && fUniqueKey.isValid() && fSyncTargetKey &&
            fCreatingProvider == GrDDLProvider::kNo) {
            GrSurface* surface = this->peekSurface();
            SkASSERT(surface);
 
            SkASSERT(surface->getUniqueKey().isValid());
            // It is possible for a non-keyed proxy to have a uniquely keyed resource assigned to
            // it. This just means that a future user of the resource will be filling it with unique
            // data. However, if the proxy has a unique key its attached resource should also
            // have that key.
            SkASSERT(fUniqueKey == surface->getUniqueKey());
        }
#endif
 
        return fUniqueKey;
    }

◆ hasRestrictedSampling()

bool GrTextureProxy::hasRestrictedSampling ( ) const

inline

If true then the texture does not support MIP maps and only supports clamp wrap mode.

Definition at line 70 of file GrTextureProxy.h.

                                       {
        return GrTextureTypeHasRestrictedSampling(this->textureType());
    }

◆ instantiate()

bool GrTextureProxy::instantiate ( GrResourceProvider * resourceProvider )

overridevirtual

Implements GrSurfaceProxy.

Definition at line 123 of file GrTextureProxy.cpp.

                                                                     {
    if (this->isLazy()) {
        return false;
    }
    if (!this->instantiateImpl(resourceProvider, 1, GrRenderable::kNo, fMipmapped,
                               fUniqueKey.isValid() ? &fUniqueKey : nullptr)) {
        return false;
    }
 
    SkASSERT(!this->peekRenderTarget());
    SkASSERT(this->peekTexture());
    return true;
}

◆ markMipmapsClean()

void GrTextureProxy::markMipmapsClean ( )

inline

Definition at line 58 of file GrTextureProxy.h.

                            {
        SkASSERT(skgpu::Mipmapped::kYes == fMipmapped);
        fMipmapStatus = GrMipmapStatus::kValid;
    }

◆ markMipmapsDirty()

void GrTextureProxy::markMipmapsDirty ( )

inline

Definition at line 54 of file GrTextureProxy.h.

                            {
        SkASSERT(skgpu::Mipmapped::kYes == fMipmapped);
        fMipmapStatus = GrMipmapStatus::kDirty;
    }

◆ mipmapped()

skgpu::Mipmapped GrTextureProxy::mipmapped ( ) const

Definition at line 166 of file GrTextureProxy.cpp.

                                               {
    if (this->isInstantiated()) {
        return this->peekTexture()->mipmapped();
    }
    return fMipmapped;
}

◆ mipmapsAreDirty()

bool GrTextureProxy::mipmapsAreDirty ( ) const

inline

Definition at line 49 of file GrTextureProxy.h.

                                 {
        SkASSERT((skgpu::Mipmapped::kNo == fMipmapped) ==
                 (GrMipmapStatus::kNotAllocated == fMipmapStatus));
        return skgpu::Mipmapped::kYes == fMipmapped && GrMipmapStatus::kValid != fMipmapStatus;
    }

◆ ProxiesAreCompatibleAsDynamicState()

bool GrTextureProxy::ProxiesAreCompatibleAsDynamicState	(	const GrSurfaceProxy *	first,
		const GrSurfaceProxy *	second
	)

static

Definition at line 181 of file GrTextureProxy.cpp.

                                                                                      {
    // In order to be compatible, the proxies should also have the same texture type. This is
    // checked explicitly since the GrBackendFormat == operator does not compare texture type
    return first->backendFormat().textureType() == second->backendFormat().textureType() &&
           first->backendFormat() == second->backendFormat();
}

◆ proxyMipmapped()

skgpu::Mipmapped GrTextureProxy::proxyMipmapped ( ) const

inline

Definition at line 65 of file GrTextureProxy.h.

65{ return fMipmapped; }

◆ setTargetKeySync()

void GrTextureProxy::setTargetKeySync ( bool sync )

inline

Definition at line 171 of file GrTextureProxy.h.

171{ fSyncTargetKey = sync; }

◆ texPriv() [1/2]

GrTextureProxyPriv GrTextureProxy::texPriv ( )

inline

Definition at line 44 of file GrTextureProxyPriv.h.

44{ return GrTextureProxyPriv(this); }

GrTextureProxy::GrTextureProxyPriv

friend class GrTextureProxyPriv

Definition: GrTextureProxy.h:120

◆ texPriv() [2/2]

const GrTextureProxyPriv GrTextureProxy::texPriv ( ) const

inline

Definition at line 46 of file GrTextureProxyPriv.h.

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

◆ textureType()

GrTextureType GrTextureProxy::textureType ( ) const

Definition at line 173 of file GrTextureProxy.cpp.

173{ return this->backendFormat().textureType(); }

Friends And Related Function Documentation

◆ GrProxyProvider

friend class (GrDDLProvider creatingProvider() const { return fCreatingProvider; }) protected GrProxyProvider

friend

Definition at line 119 of file GrTextureProxy.h.

◆ GrSurfaceProxyPriv

friend class GrSurfaceProxyPriv

friend

Definition at line 121 of file GrTextureProxy.h.

◆ GrTextureProxyPriv

friend class GrTextureProxyPriv

friend

Definition at line 120 of file GrTextureProxy.h.

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

third_party/skia/src/gpu/ganesh/GrTextureProxy.h
third_party/skia/src/gpu/ganesh/GrTextureProxy.cpp
third_party/skia/src/gpu/ganesh/GrTextureProxyCacheAccess.h
third_party/skia/src/gpu/ganesh/GrTextureProxyPriv.h

Classes

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GrTextureProxy() [1/3]

◆ GrTextureProxy() [2/3]

◆ GrTextureProxy() [3/3]

◆ ~GrTextureProxy()

Member Function Documentation

◆ asTextureProxy() [1/2]

◆ asTextureProxy() [2/2]

◆ cacheAccess() [1/2]

◆ cacheAccess() [2/2]

◆ createSurface()

◆ getUniqueKey()

◆ hasRestrictedSampling()

◆ instantiate()

◆ markMipmapsClean()

◆ markMipmapsDirty()

◆ mipmapped()

◆ mipmapsAreDirty()

◆ ProxiesAreCompatibleAsDynamicState()

◆ proxyMipmapped()

◆ setTargetKeySync()

◆ texPriv() [1/2]

◆ texPriv() [2/2]

◆ textureType()

Friends And Related Function Documentation

◆ GrProxyProvider

◆ GrSurfaceProxyPriv

◆ GrTextureProxyPriv