#include <SkImage_Ganesh.h>

Inheritance diagram for SkImage_Ganesh:

Public Member Functions
	SkImage_Ganesh (sk_sp< GrImageContext > context, uint32_t uniqueID, GrSurfaceProxyView view, SkColorInfo info)

	~SkImage_Ganesh () override

size_t	textureSize () const override

SkImage_Base::Type	type () const override

bool	onHasMipmaps () const override

bool	onIsProtected () const override

sk_sp< SkImage >	onMakeColorTypeAndColorSpace (SkColorType, sk_sp< SkColorSpace >, GrDirectContext *) const final

sk_sp< SkImage >	onReinterpretColorSpace (sk_sp< SkColorSpace >) const final

void	onAsyncRescaleAndReadPixels (const SkImageInfo &, SkIRect srcRect, RescaleGamma, RescaleMode, ReadPixelsCallback, ReadPixelsContext) const override

void	onAsyncRescaleAndReadPixelsYUV420 (SkYUVColorSpace, bool readAlpha, sk_sp< SkColorSpace >, SkIRect srcRect, SkISize dstSize, RescaleGamma, RescaleMode, ReadPixelsCallback, ReadPixelsContext) const override

void	generatingSurfaceIsDeleted () override

GrSemaphoresSubmitted	flush (GrDirectContext *, const GrFlushInfo &) const override

std::tuple< GrSurfaceProxyView, GrColorType >	asView (GrRecordingContext *, skgpu::Mipmapped, GrImageTexGenPolicy) const override

std::unique_ptr< GrFragmentProcessor >	asFragmentProcessor (GrRecordingContext , SkSamplingOptions, const SkTileMode[2], const SkMatrix &, const SkRect , const SkRect *) const override

bool	surfaceMustCopyOnWrite (GrSurfaceProxy *surfaceProxy) const

bool	getExistingBackendTexture (GrBackendTexture outTexture, bool flushPendingGrContextIO, GrSurfaceOrigin origin) const

GrSurfaceOrigin	origin () const override

Public Member Functions inherited from SkImage_GaneshBase
bool	isValid (GrRecordingContext *) const final

sk_sp< SkImage >	makeColorTypeAndColorSpace (GrDirectContext *dContext, SkColorType targetColorType, sk_sp< SkColorSpace > targetCS) const final

sk_sp< SkImage >	makeSubset (GrDirectContext *direct, const SkIRect &subset) const final

GrImageContext *	context () const final

GrDirectContext *	directContext () const final

bool	getROPixels (GrDirectContext , SkBitmap , CachingHint) const final

sk_sp< SkImage >	onMakeSubset (GrDirectContext *, const SkIRect &subset) const final

bool	onReadPixels (GrDirectContext dContext, const SkImageInfo &dstInfo, void dstPixels, size_t dstRB, int srcX, int srcY, CachingHint) const override

Public Member Functions inherited from SkImage_Base
	~SkImage_Base () override

sk_sp< SkImage >	makeColorSpace (GrDirectContext *, sk_sp< SkColorSpace >) const override

sk_sp< SkImage >	makeColorSpace (skgpu::graphite::Recorder *, sk_sp< SkColorSpace >, RequiredProperties) const override

sk_sp< SkImage >	makeSubset (skgpu::graphite::Recorder *, const SkIRect &, RequiredProperties) const override

virtual bool	onPeekPixels (SkPixmap *) const

virtual const SkBitmap *	onPeekBitmap () const

virtual SkMipmap *	onPeekMips () const

sk_sp< SkMipmap >	refMips () const

virtual sk_sp< SkData >	onRefEncoded () const

virtual bool	onAsLegacyBitmap (GrDirectContext , SkBitmap ) const

bool	isLazyGenerated () const override

bool	isRasterBacked () const

bool	isGaneshBacked () const

bool	isGraphiteBacked () const

bool	isYUVA () const

bool	isTextureBacked () const override

virtual void	notifyAddedToRasterCache () const

virtual sk_sp< SkImage >	onMakeWithMipmaps (sk_sp< SkMipmap >) const

Public Member Functions inherited from SkImage
const SkImageInfo &	imageInfo () const

int	width () const

int	height () const

SkISize	dimensions () const

SkIRect	bounds () const

uint32_t	uniqueID () const

SkAlphaType	alphaType () const

SkColorType	colorType () const

SkColorSpace *	colorSpace () const

sk_sp< SkColorSpace >	refColorSpace () const

bool	isAlphaOnly () const

bool	isOpaque () const

sk_sp< SkShader >	makeShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &, const SkMatrix *localMatrix=nullptr) const

sk_sp< SkShader >	makeShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &sampling, const SkMatrix &lm) const

sk_sp< SkShader >	makeShader (const SkSamplingOptions &sampling, const SkMatrix &lm) const

sk_sp< SkShader >	makeShader (const SkSamplingOptions &sampling, const SkMatrix *lm=nullptr) const

sk_sp< SkShader >	makeRawShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &, const SkMatrix *localMatrix=nullptr) const

sk_sp< SkShader >	makeRawShader (SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions &sampling, const SkMatrix &lm) const

sk_sp< SkShader >	makeRawShader (const SkSamplingOptions &sampling, const SkMatrix &lm) const

sk_sp< SkShader >	makeRawShader (const SkSamplingOptions &sampling, const SkMatrix *lm=nullptr) const

bool	peekPixels (SkPixmap *pixmap) const

bool	readPixels (GrDirectContext context, const SkImageInfo &dstInfo, void dstPixels, size_t dstRowBytes, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const

bool	readPixels (GrDirectContext *context, const SkPixmap &dst, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const

bool	readPixels (const SkImageInfo &dstInfo, void *dstPixels, size_t dstRowBytes, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const

bool	readPixels (const SkPixmap &dst, int srcX, int srcY, CachingHint cachingHint=kAllow_CachingHint) const

void	asyncRescaleAndReadPixels (const SkImageInfo &info, const SkIRect &srcRect, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) const

void	asyncRescaleAndReadPixelsYUV420 (SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) const

void	asyncRescaleAndReadPixelsYUVA420 (SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) const

bool	scalePixels (const SkPixmap &dst, const SkSamplingOptions &, CachingHint cachingHint=kAllow_CachingHint) const

sk_sp< SkData >	refEncodedData () const

bool	hasMipmaps () const

bool	isProtected () const

sk_sp< SkImage >	withDefaultMipmaps () const

sk_sp< SkImage >	makeNonTextureImage (GrDirectContext *=nullptr) const

sk_sp< SkImage >	makeRasterImage (GrDirectContext *, CachingHint cachingHint=kDisallow_CachingHint) const

sk_sp< SkImage >	makeRasterImage (CachingHint cachingHint=kDisallow_CachingHint) const

bool	asLegacyBitmap (SkBitmap *bitmap, LegacyBitmapMode legacyBitmapMode=kRO_LegacyBitmapMode) const

sk_sp< SkImage >	reinterpretColorSpace (sk_sp< SkColorSpace > newColorSpace) const

Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()

virtual	~SkRefCntBase ()

bool	unique () const

void	ref () const

void	unref () const

Static Public Member Functions
static sk_sp< SkImage >	MakeWithVolatileSrc (sk_sp< GrRecordingContext > rContext, GrSurfaceProxyView volatileSrc, SkColorInfo colorInfo)

Static Public Member Functions inherited from SkImage_GaneshBase
static bool	ValidateBackendTexture (const GrCaps *, const GrBackendTexture &tex, GrColorType grCT, SkColorType ct, SkAlphaType at, sk_sp< SkColorSpace > cs)

static bool	ValidateCompressedBackendTexture (const GrCaps *, const GrBackendTexture &tex, SkAlphaType)

static sk_sp< GrTextureProxy >	MakePromiseImageLazyProxy (GrContextThreadSafeProxy *, SkISize dimensions, const GrBackendFormat &, skgpu::Mipmapped, SkImages::PromiseImageTextureFulfillProc, sk_sp< skgpu::RefCntedCallback > releaseHelper)

Additional Inherited Members
Public Types inherited from SkImage_Base
enum class	Type { kRaster , kRasterPinnable , kLazy , kLazyPicture , kGanesh , kGaneshYUVA , kGraphite , kGraphiteYUVA }

Public Types inherited from SkImage
enum	CachingHint { kAllow_CachingHint , kDisallow_CachingHint }

enum class	RescaleGamma : bool { kSrc , kLinear }

enum class	RescaleMode { kNearest , kLinear , kRepeatedLinear , kRepeatedCubic }

enum	LegacyBitmapMode { kRO_LegacyBitmapMode }

using	ReadPixelsContext = void *

using	ReadPixelsCallback = void(ReadPixelsContext, std::unique_ptr< const AsyncReadResult >)

Protected Member Functions inherited from SkImage_GaneshBase
	SkImage_GaneshBase (sk_sp< GrImageContext >, SkImageInfo, uint32_t uniqueID)

sk_sp< SkImage >	onMakeSubset (skgpu::graphite::Recorder *, const SkIRect &subset, RequiredProperties) const final

sk_sp< SkImage >	makeColorTypeAndColorSpace (skgpu::graphite::Recorder *, SkColorType, sk_sp< SkColorSpace >, RequiredProperties) const final

virtual sk_sp< SkImage >	onMakeColorTypeAndColorSpace (SkColorType, sk_sp< SkColorSpace >, GrDirectContext *) const=0

Protected Member Functions inherited from SkImage_Base
	SkImage_Base (const SkImageInfo &info, uint32_t uniqueID)

Protected Attributes inherited from SkImage_GaneshBase
sk_sp< GrImageContext >	fContext

Detailed Description

Definition at line 55 of file SkImage_Ganesh.h.

Constructor & Destructor Documentation

◆ SkImage_Ganesh()

SkImage_Ganesh::SkImage_Ganesh	(	sk_sp< GrImageContext >	context,
		uint32_t	uniqueID,
		GrSurfaceProxyView	view,
		SkColorInfo	info
	)

Definition at line 157 of file SkImage_Ganesh.cpp.

        : INHERITED(std::move(context),
                    SkImageInfo::Make(view.proxy()->backingStoreDimensions(), std::move(info)),
                    uniqueID)
        , fChooser(view.detachProxy())
        , fSwizzle(view.swizzle())
        , fOrigin(view.origin()) {
#ifdef SK_DEBUG
    const GrBackendFormat& format = fChooser.backendFormat();
    const GrCaps* caps = this->context()->priv().caps();
    GrColorType grCT = SkColorTypeToGrColorType(this->colorType());
    SkASSERT(caps->isFormatCompressed(format) ||
             caps->areColorTypeAndFormatCompatible(grCT, format));
#endif
}

◆ ~SkImage_Ganesh()

SkImage_Ganesh::~SkImage_Ganesh ( )

overridedefault

Member Function Documentation

◆ asFragmentProcessor()

std::unique_ptr< GrFragmentProcessor > SkImage_Ganesh::asFragmentProcessor	(	GrRecordingContext *	rContext,
		SkSamplingOptions	sampling,
		const SkTileMode	tileModes[2],
		const SkMatrix &	m,
		const SkRect *	subset,
		const SkRect *	domain
	)		const

overridevirtual

Implements SkImage_GaneshBase.

Definition at line 431 of file SkImage_Ganesh.cpp.

                                    {
    if (!fContext->priv().matches(rContext)) {
        return {};
    }
    auto mm =
            sampling.mipmap == SkMipmapMode::kNone ? skgpu::Mipmapped::kNo : skgpu::Mipmapped::kYes;
    return skgpu::ganesh::MakeFragmentProcessorFromView(
            rContext,
            std::get<0>(skgpu::ganesh::AsView(rContext, this, mm)),
            this->alphaType(),
            sampling,
            tileModes,
            m,
            subset,
            domain);
}

◆ asView()

std::tuple< GrSurfaceProxyView, GrColorType > SkImage_Ganesh::asView	(	GrRecordingContext *	recordingContext,
		skgpu::Mipmapped	mipmapped,
		GrImageTexGenPolicy	policy
	)		const

overridevirtual

Implements SkImage_GaneshBase.

Definition at line 407 of file SkImage_Ganesh.cpp.

                                          {
    if (!fContext->priv().matches(recordingContext)) {
        return {};
    }
    if (policy != GrImageTexGenPolicy::kDraw) {
        return {skgpu::ganesh::CopyView(recordingContext,
                                        this->makeView(recordingContext),
                                        mipmapped,
                                        policy,
                                        /*label=*/"SkImageGpu_AsView"),
                SkColorTypeToGrColorType(this->colorType())};
    }
    GrSurfaceProxyView view = this->makeView(recordingContext);
    GrColorType ct = SkColorTypeToGrColorType(this->colorType());
    if (mipmapped == skgpu::Mipmapped::kYes) {
        view = skgpu::ganesh::FindOrMakeCachedMipmappedView(recordingContext, std::move(view),
                                                            this->uniqueID());
    }
    return {std::move(view), ct};
}

◆ flush()

GrSemaphoresSubmitted SkImage_Ganesh::flush	(	GrDirectContext *	dContext,
		const GrFlushInfo &	info
	)		const

overridevirtual

Implements SkImage_GaneshBase.

Definition at line 249 of file SkImage_Ganesh.cpp.

                                                                           {
    if (!fContext->priv().matches(dContext) || dContext->abandoned()) {
        if (info.fSubmittedProc) {
            info.fSubmittedProc(info.fSubmittedContext, false);
        }
        if (info.fFinishedProc) {
            info.fFinishedProc(info.fFinishedContext);
        }
        return GrSemaphoresSubmitted::kNo;
    }
 
    sk_sp<GrSurfaceProxy> proxy = fChooser.chooseProxy(dContext);
    return dContext->priv().flushSurface(
            proxy.get(), SkSurfaces::BackendSurfaceAccess::kNoAccess, info);
}

◆ generatingSurfaceIsDeleted()

void SkImage_Ganesh::generatingSurfaceIsDeleted ( )

overridevirtual

Reimplemented from SkImage_Base.

Definition at line 405 of file SkImage_Ganesh.cpp.

405{ fChooser.makeVolatileProxyStable(); }

◆ getExistingBackendTexture()

bool SkImage_Ganesh::getExistingBackendTexture	(	GrBackendTexture *	outTexture,
		bool	flushPendingGrContextIO,
		GrSurfaceOrigin *	origin
	)		const

Definition at line 266 of file SkImage_Ganesh.cpp.

                                                                              {
    auto direct = fContext->asDirectContext();
    if (!direct) {
        // This image was created with a DDL context and cannot be instantiated.
        return false;
    }
    if (direct->abandoned()) {
        return false;
    }
 
    // We don't know how client's use of the texture will be ordered WRT Skia's. Ensure the
    // texture seen by the client won't be mutated by a SkSurface.
    sk_sp<GrSurfaceProxy> proxy = fChooser.switchToStableProxy();
 
    if (!proxy->isInstantiated()) {
        auto resourceProvider = direct->priv().resourceProvider();
 
        if (!proxy->instantiate(resourceProvider)) {
            return false;
        }
    }
 
    GrTexture* texture = proxy->peekTexture();
    if (!texture) {
        return false;
    }
    if (flushPendingGrContextIO) {
        direct->priv().flushSurface(proxy.get());
    }
    if (origin) {
        *origin = fOrigin;
    }
    if (outTexture) {
        *outTexture = texture->getBackendTexture();
    }
    return true;
}

◆ MakeWithVolatileSrc()

sk_sp< SkImage > SkImage_Ganesh::MakeWithVolatileSrc	(	sk_sp< GrRecordingContext >	rContext,
		GrSurfaceProxyView	volatileSrc,
		SkColorInfo	colorInfo
	)

static

Definition at line 201 of file SkImage_Ganesh.cpp.

                                                                          {
    SkASSERT(rContext);
    SkASSERT(volatileSrc);
    SkASSERT(volatileSrc.proxy()->asTextureProxy());
    skgpu::Mipmapped mm = volatileSrc.proxy()->asTextureProxy()->mipmapped();
    sk_sp<GrRenderTask> copyTask;
    auto copy = GrSurfaceProxy::Copy(rContext.get(),
                                     volatileSrc.refProxy(),
                                     volatileSrc.origin(),
                                     mm,
                                     SkBackingFit::kExact,
                                     skgpu::Budgeted::kYes,
                                     /*label=*/"ImageGpu_MakeWithVolatileSrc",
                                     &copyTask);
    if (!copy) {
        return nullptr;
    }
    // We only attempt to make a dual-proxy image on a direct context. This optimziation requires
    // knowing how things are ordered and recording-only contexts are not well ordered WRT other
    // recording contexts.
    if (auto direct = sk_ref_sp(rContext->asDirectContext())) {
        int targetCount = volatileSrc.proxy()->getTaskTargetCount();
        return sk_sp<SkImage>(new SkImage_Ganesh(std::move(direct),
                                                 std::move(volatileSrc),
                                                 std::move(copy),
                                                 std::move(copyTask),
                                                 targetCount,
                                                 std::move(colorInfo)));
    }
    GrSurfaceProxyView copyView(std::move(copy), volatileSrc.origin(), volatileSrc.swizzle());
    return sk_make_sp<SkImage_Ganesh>(
            std::move(rContext), kNeedNewImageUniqueID, std::move(copyView), std::move(colorInfo));
}

◆ onAsyncRescaleAndReadPixels()

void SkImage_Ganesh::onAsyncRescaleAndReadPixels	(	const SkImageInfo &	info,
		SkIRect	srcRect,
		RescaleGamma	rescaleGamma,
		RescaleMode	rescaleMode,
		ReadPixelsCallback	callback,
		ReadPixelsContext	context
	)		const

overridevirtual

Default implementation does a rescale/read and then calls the callback.

Reimplemented from SkImage_Base.

Definition at line 352 of file SkImage_Ganesh.cpp.

                                                                                  {
    auto dContext = fContext->asDirectContext();
    if (!dContext) {
        // DDL TODO: buffer up the readback so it occurs when the DDL is drawn?
        callback(context, nullptr);
        return;
    }
    auto ctx = dContext->priv().makeSC(this->makeView(dContext), this->imageInfo().colorInfo());
    if (!ctx) {
        callback(context, nullptr);
        return;
    }
    ctx->asyncRescaleAndReadPixels(
            dContext, info, srcRect, rescaleGamma, rescaleMode, callback, context);
}

◆ onAsyncRescaleAndReadPixelsYUV420()

void SkImage_Ganesh::onAsyncRescaleAndReadPixelsYUV420	(	SkYUVColorSpace	,
		bool	readAlpha,
		sk_sp< SkColorSpace >	dstColorSpace,
		SkIRect	srcRect,
		SkISize	dstSize,
		RescaleGamma	,
		RescaleMode	,
		ReadPixelsCallback	callback,
		ReadPixelsContext	context
	)		const

overridevirtual

Default implementation does a rescale/read/yuv conversion and then calls the callback.

Reimplemented from SkImage_Base.

Definition at line 373 of file SkImage_Ganesh.cpp.

                                                                                        {
    auto dContext = fContext->asDirectContext();
    if (!dContext) {
        // DDL TODO: buffer up the readback so it occurs when the DDL is drawn?
        callback(context, nullptr);
        return;
    }
    auto ctx = dContext->priv().makeSC(this->makeView(dContext), this->imageInfo().colorInfo());
    if (!ctx) {
        callback(context, nullptr);
        return;
    }
    ctx->asyncRescaleAndReadPixelsYUV420(dContext,
                                         yuvColorSpace,
                                         readAlpha,
                                         std::move(dstColorSpace),
                                         srcRect,
                                         dstSize,
                                         rescaleGamma,
                                         rescaleMode,
                                         callback,
                                         context);
}

◆ onHasMipmaps()

bool SkImage_Ganesh::onHasMipmaps ( ) const

overridevirtual

Implements SkImage_Base.

Definition at line 243 of file SkImage_Ganesh.cpp.

243{ return fChooser.mipmapped() == skgpu::Mipmapped::kYes; }

◆ onIsProtected()

bool SkImage_Ganesh::onIsProtected ( ) const

overridevirtual

Implements SkImage_Base.

Definition at line 245 of file SkImage_Ganesh.cpp.

                                         {
    return fChooser.isProtected() == skgpu::Protected::kYes;
}

◆ onMakeColorTypeAndColorSpace()

sk_sp< SkImage > SkImage_Ganesh::onMakeColorTypeAndColorSpace	(	SkColorType	targetCT,
		sk_sp< SkColorSpace >	targetCS,
		GrDirectContext *	dContext
	)		const

finalvirtual

Implements SkImage_Base.

Definition at line 308 of file SkImage_Ganesh.cpp.

                                                                                             {
    SkColorInfo info(targetCT, this->alphaType(), std::move(targetCS));
    if (!fContext->priv().matches(dContext)) {
        return nullptr;
    }
 
    sk_sp<GrSurfaceProxy> proxy = fChooser.chooseProxy(dContext);
 
    auto sfc = dContext->priv().makeSFCWithFallback(GrImageInfo(info, this->dimensions()),
                                                    SkBackingFit::kExact,
                                                    /* sampleCount= */ 1,
                                                    skgpu::Mipmapped::kNo,
                                                    proxy->isProtected());
    if (!sfc) {
        return nullptr;
    }
    // We respecify info's CT because we called MakeWithFallback.
    auto ct = GrColorTypeToSkColorType(sfc->colorInfo().colorType());
    info = info.makeColorType(ct);
 
    // Draw this image's texture into the SFC.
    auto [view, _] = skgpu::ganesh::AsView(dContext, this, skgpu::Mipmapped(this->hasMipmaps()));
    auto texFP = GrTextureEffect::Make(std::move(view), this->alphaType());
    auto colorFP =
            GrColorSpaceXformEffect::Make(std::move(texFP), this->imageInfo().colorInfo(), info);
    sfc->fillWithFP(std::move(colorFP));
 
    return sk_make_sp<SkImage_Ganesh>(
            sk_ref_sp(dContext), kNeedNewImageUniqueID, sfc->readSurfaceView(), std::move(info));
}

◆ onReinterpretColorSpace()

sk_sp< SkImage > SkImage_Ganesh::onReinterpretColorSpace ( sk_sp< SkColorSpace > newCS ) const

finalvirtual

Implements SkImage_Base.

Definition at line 341 of file SkImage_Ganesh.cpp.

                                                                                      {
    // It doesn't seem worth the complexity of trying to share the ProxyChooser among multiple
    // images. Just fall back to the stable copy.
    GrSurfaceProxyView view(fChooser.switchToStableProxy(), fOrigin, fSwizzle);
    return sk_make_sp<SkImage_Ganesh>(
            fContext,
            kNeedNewImageUniqueID,
            std::move(view),
            this->imageInfo().colorInfo().makeColorSpace(std::move(newCS)));
}

◆ origin()

GrSurfaceOrigin SkImage_Ganesh::origin ( ) const

inlineoverridevirtual

Implements SkImage_GaneshBase.

Definition at line 126 of file SkImage_Ganesh.h.

126{ return fOrigin; }

◆ surfaceMustCopyOnWrite()

bool SkImage_Ganesh::surfaceMustCopyOnWrite ( GrSurfaceProxy * surfaceProxy ) const

Definition at line 239 of file SkImage_Ganesh.cpp.

                                                                              {
    return fChooser.surfaceMustCopyOnWrite(surfaceProxy);
}

◆ textureSize()

size_t SkImage_Ganesh::textureSize ( ) const

overridevirtual

Returns an approximation of the amount of texture memory used by the image. Returns zero if the image is not texture backed or if the texture has an external format.

Reimplemented from SkImage_Base.

Definition at line 306 of file SkImage_Ganesh.cpp.

306{ return fChooser.gpuMemorySize(); }

◆ type()

SkImage_Base::Type SkImage_Ganesh::type ( ) const

inlineoverridevirtual

Implements SkImage_Base.

Definition at line 72 of file SkImage_Ganesh.h.

72{ return SkImage_Base::Type::kGanesh; }

SkImage_Base::Type::kGanesh

@ kGanesh

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

third_party/skia/src/gpu/ganesh/image/SkImage_Ganesh.h
third_party/skia/src/gpu/ganesh/image/SkImage_Ganesh.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SkImage_Ganesh()

◆ ~SkImage_Ganesh()

Member Function Documentation

◆ asFragmentProcessor()

◆ asView()

◆ flush()

◆ generatingSurfaceIsDeleted()

◆ getExistingBackendTexture()

◆ MakeWithVolatileSrc()

◆ onAsyncRescaleAndReadPixels()

◆ onAsyncRescaleAndReadPixelsYUV420()

◆ onHasMipmaps()

◆ onIsProtected()

◆ onMakeColorTypeAndColorSpace()

◆ onReinterpretColorSpace()

◆ origin()

◆ surfaceMustCopyOnWrite()

◆ textureSize()

◆ type()