SkSurface_Ganesh Class Reference

#include <SkSurface_Ganesh.h>

Inheritance diagram for SkSurface_Ganesh:

Public Member Functions
	SkSurface_Ganesh (sk_sp< skgpu::ganesh::Device >)
	~SkSurface_Ganesh () override
SkImageInfo	imageInfo () const override
bool	replaceBackendTexture (const GrBackendTexture &, GrSurfaceOrigin, ContentChangeMode, TextureReleaseProc, ReleaseContext) override
SkSurface_Base::Type	type () const override
GrRecordingContext *	onGetRecordingContext () const override
SkCanvas *	onNewCanvas () override
sk_sp< SkSurface >	onNewSurface (const SkImageInfo &) override
sk_sp< SkImage >	onNewImageSnapshot (const SkIRect *subset) override
void	onWritePixels (const SkPixmap &, int x, int y) override
void	onAsyncRescaleAndReadPixels (const SkImageInfo &info, SkIRect srcRect, RescaleGamma rescaleGamma, RescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) override
void	onAsyncRescaleAndReadPixelsYUV420 (SkYUVColorSpace yuvColorSpace, bool readAlpha, sk_sp< SkColorSpace > dstColorSpace, SkIRect srcRect, SkISize dstSize, RescaleGamma rescaleGamma, RescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) override
bool	onCopyOnWrite (ContentChangeMode) override
void	onDiscard () override
bool	onWait (int numSemaphores, const GrBackendSemaphore *waitSemaphores, bool deleteSemaphoresAfterWait) override
bool	onCharacterize (GrSurfaceCharacterization *) const override
bool	onIsCompatible (const GrSurfaceCharacterization &) const override
void	onDraw (SkCanvas *canvas, SkScalar x, SkScalar y, const SkSamplingOptions &, const SkPaint *paint) override
sk_sp< const SkCapabilities >	onCapabilities () override
skgpu::ganesh::Device *	getDevice ()
GrBackendTexture	getBackendTexture (BackendHandleAccess)
GrBackendRenderTarget	getBackendRenderTarget (BackendHandleAccess)
void	resolveMSAA ()
bool	draw (sk_sp< const GrDeferredDisplayList >)
Public Member Functions inherited from SkSurface_Base
	SkSurface_Base (int width, int height, const SkSurfaceProps *)
	SkSurface_Base (const SkImageInfo &, const SkSurfaceProps *)
	~SkSurface_Base () override
bool	isRasterBacked () const
bool	isGaneshBacked () const
bool	isGraphiteBacked () const
virtual skgpu::graphite::Recorder *	onGetRecorder () const
virtual void	onRestoreBackingMutability ()
SkCanvas *	getCachedCanvas ()
sk_sp< SkImage >	refCachedImage ()
bool	hasCachedImage () const
uint32_t	newGenerationID ()
Public Member Functions inherited from SkSurface
bool	isCompatible (const GrSurfaceCharacterization &characterization) const
int	width () const
int	height () const
uint32_t	generationID ()
void	notifyContentWillChange (ContentChangeMode mode)
GrRecordingContext *	recordingContext () const
skgpu::graphite::Recorder *	recorder () const
SkCanvas *	getCanvas ()
sk_sp< const SkCapabilities >	capabilities ()
sk_sp< SkSurface >	makeSurface (const SkImageInfo &imageInfo)
sk_sp< SkSurface >	makeSurface (int width, int height)
sk_sp< SkImage >	makeImageSnapshot ()
sk_sp< SkImage >	makeImageSnapshot (const SkIRect &bounds)
void	draw (SkCanvas *canvas, SkScalar x, SkScalar y, const SkSamplingOptions &sampling, const SkPaint *paint)
void	draw (SkCanvas *canvas, SkScalar x, SkScalar y, const SkPaint *paint=nullptr)
bool	peekPixels (SkPixmap *pixmap)
bool	readPixels (const SkPixmap &dst, int srcX, int srcY)
bool	readPixels (const SkImageInfo &dstInfo, void *dstPixels, size_t dstRowBytes, int srcX, int srcY)
bool	readPixels (const SkBitmap &dst, int srcX, int srcY)
void	asyncRescaleAndReadPixels (const SkImageInfo &info, const SkIRect &srcRect, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context)
void	asyncRescaleAndReadPixelsYUV420 (SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context)
void	asyncRescaleAndReadPixelsYUVA420 (SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context)
void	writePixels (const SkPixmap &src, int dstX, int dstY)
void	writePixels (const SkBitmap &src, int dstX, int dstY)
const SkSurfaceProps &	props () const
bool	wait (int numSemaphores, const GrBackendSemaphore *waitSemaphores, bool deleteSemaphoresAfterWait=true)
bool	characterize (GrSurfaceCharacterization *characterization) const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Additional Inherited Members
Public Types inherited from SkSurface_Base
enum class	Type { kNull , kGanesh , kGraphite , kRaster }
Public Types inherited from SkSurface
enum	ContentChangeMode { kDiscard_ContentChangeMode , kRetain_ContentChangeMode }
enum class	BackendHandleAccess {   kFlushRead , kFlushWrite , kDiscardWrite , kFlushRead_BackendHandleAccess = kFlushRead ,   kFlushWrite_BackendHandleAccess = kFlushWrite , kDiscardWrite_BackendHandleAccess = kDiscardWrite }
using	ReleaseContext = void *
using	TextureReleaseProc = void(*)(ReleaseContext)
using	AsyncReadResult = SkImage::AsyncReadResult
using	ReadPixelsContext = void *
using	ReadPixelsCallback = void(ReadPixelsContext, std::unique_ptr< const AsyncReadResult >)
using	RescaleGamma = SkImage::RescaleGamma
using	RescaleMode = SkImage::RescaleMode
Static Public Attributes inherited from SkSurface
static constexpr BackendHandleAccess	kFlushRead_BackendHandleAccess
static constexpr BackendHandleAccess	kFlushWrite_BackendHandleAccess
static constexpr BackendHandleAccess	kDiscardWrite_BackendHandleAccess
Protected Member Functions inherited from SkSurface
	SkSurface (int width, int height, const SkSurfaceProps *surfaceProps)
	SkSurface (const SkImageInfo &imageInfo, const SkSurfaceProps *surfaceProps)
void	dirtyGenerationID ()

Detailed Description

Definition at line 40 of file SkSurface_Ganesh.h.

Constructor & Destructor Documentation

SkSurface_Ganesh()

SkSurface_Ganesh::SkSurface_Ganesh

(

sk_sp< skgpu::ganesh::Device >

device

)

Definition at line 65 of file SkSurface_Ganesh.cpp.

        : INHERITED(device->width(), device->height(), &device->surfaceProps())
        , fDevice(std::move(device)) {
    SkASSERT(fDevice->targetProxy()->priv().isExact());
}

~SkSurface_Ganesh()

SkSurface_Ganesh::~SkSurface_Ganesh ( )

override

Definition at line 71 of file SkSurface_Ganesh.cpp.

                                    {
    if (this->hasCachedImage()) {
        as_IB(this->refCachedImage())->generatingSurfaceIsDeleted();
    }
}

Member Function Documentation

draw()

bool SkSurface_Ganesh::draw

(

sk_sp< const GrDeferredDisplayList >

ddl

)

Definition at line 406 of file SkSurface_Ganesh.cpp.

                                                                  {
    if (!ddl || !this->isCompatible(ddl->characterization())) {
        return false;
    }
 
    auto direct = fDevice->recordingContext()->asDirectContext();
    if (!direct || direct->abandoned()) {
        return false;
    }
 
    GrSurfaceProxyView view = fDevice->readSurfaceView();
 
    direct->priv().createDDLTask(std::move(ddl), view.asRenderTargetProxyRef());
    return true;
}

getBackendRenderTarget()

GrBackendRenderTarget SkSurface_Ganesh::getBackendRenderTarget

(

BackendHandleAccess

access

)

Definition at line 123 of file SkSurface_Ganesh.cpp.

                                                                                         {
    GrRenderTarget* rt = prepare_rt_for_external_access(this, access);
    if (!rt) {
        return GrBackendRenderTarget();  // invalid
    }
 
    return rt->getBackendRenderTarget();
}

getBackendTexture()

GrBackendTexture SkSurface_Ganesh::getBackendTexture

(

BackendHandleAccess

access

)

Definition at line 111 of file SkSurface_Ganesh.cpp.

                                                                               {
    GrRenderTarget* rt = prepare_rt_for_external_access(this, access);
    if (!rt) {
        return GrBackendTexture();  // invalid
    }
    GrTexture* texture = rt->asTexture();
    if (texture) {
        return texture->getBackendTexture();
    }
    return GrBackendTexture();  // invalid
}

getDevice()

skgpu::ganesh::Device * SkSurface_Ganesh::getDevice

(

)

Definition at line 81 of file SkSurface_Ganesh.cpp.

{ return fDevice.get(); }

imageInfo()

SkImageInfo SkSurface_Ganesh::imageInfo ( ) const

overridevirtual

Returns an ImageInfo describing the surface.

Reimplemented from SkSurface.

Definition at line 83 of file SkSurface_Ganesh.cpp.

{ return fDevice->imageInfo(); }

onAsyncRescaleAndReadPixels()

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

overridevirtual

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

Reimplemented from SkSurface_Base.

Definition at line 195 of file SkSurface_Ganesh.cpp.

                                                                              {
    fDevice->asyncRescaleAndReadPixels(info, srcRect, rescaleGamma, rescaleMode, callback, context);
}

onAsyncRescaleAndReadPixelsYUV420()

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

overridevirtual

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

Reimplemented from SkSurface_Base.

Definition at line 204 of file SkSurface_Ganesh.cpp.

                                                                                    {
    fDevice->asyncRescaleAndReadPixelsYUV420(yuvColorSpace,
                                             readAlpha,
                                             std::move(dstColorSpace),
                                             srcRect,
                                             dstSize,
                                             rescaleGamma,
                                             rescaleMode,
                                             callback,
                                             context);
}

onCapabilities()

sk_sp< const SkCapabilities > SkSurface_Ganesh::onCapabilities ( )

overridevirtual

Reimplemented from SkSurface_Base.

Definition at line 422 of file SkSurface_Ganesh.cpp.

                                                             {
    return fDevice->recordingContext()->skCapabilities();
}

onCharacterize()

bool SkSurface_Ganesh::onCharacterize ( GrSurfaceCharacterization *  characterization ) const

overridevirtual

Reimplemented from SkSurface_Base.

Definition at line 256 of file SkSurface_Ganesh.cpp.

                                                                                       {
    auto direct = fDevice->recordingContext()->asDirectContext();
    if (!direct) {
        return false;
    }
 
    SkImageInfo ii = fDevice->imageInfo();
    if (ii.colorType() == kUnknown_SkColorType) {
        return false;
    }
 
    GrSurfaceProxyView readSurfaceView = fDevice->readSurfaceView();
    size_t maxResourceBytes = direct->getResourceCacheLimit();
 
    skgpu::Mipmapped mipmapped = readSurfaceView.asTextureProxy()
                                         ? readSurfaceView.asTextureProxy()->mipmapped()
                                         : skgpu::Mipmapped::kNo;
 
    bool usesGLFBO0 = readSurfaceView.asRenderTargetProxy()->glRTFBOIDIs0();
    // We should never get in the situation where we have a texture render target that is also
    // backend by FBO 0.
    SkASSERT(!usesGLFBO0 || !SkToBool(readSurfaceView.asTextureProxy()));
 
    bool vkRTSupportsInputAttachment =
            readSurfaceView.asRenderTargetProxy()->supportsVkInputAttachment();
 
    GrBackendFormat format = readSurfaceView.proxy()->backendFormat();
    int numSamples = readSurfaceView.asRenderTargetProxy()->numSamples();
    GrProtected isProtected = readSurfaceView.asRenderTargetProxy()->isProtected();
 
    characterization->set(
            direct->threadSafeProxy(),
            maxResourceBytes,
            ii,
            format,
            readSurfaceView.origin(),
            numSamples,
            GrSurfaceCharacterization::Textureable(SkToBool(readSurfaceView.asTextureProxy())),
            mipmapped,
            GrSurfaceCharacterization::UsesGLFBO0(usesGLFBO0),
            GrSurfaceCharacterization::VkRTSupportsInputAttachment(vkRTSupportsInputAttachment),
            GrSurfaceCharacterization::VulkanSecondaryCBCompatible(false),
            isProtected,
            this->props());
    return true;
}

onCopyOnWrite()

bool SkSurface_Ganesh::onCopyOnWrite ( ContentChangeMode  )

overridevirtual

If the surface is about to change, we call this so that our subclass can optionally fork their backend (copy-on-write) in case it was being shared with the cachedImage.

Returns false if the backing cannot be un-shared.

Implements SkSurface_Base.

Definition at line 227 of file SkSurface_Ganesh.cpp.

                                                           {
    GrSurfaceProxyView readSurfaceView = fDevice->readSurfaceView();
 
    // are we sharing our backing proxy with the image? Note this call should never create a new
    // image because onCopyOnWrite is only called when there is a cached image.
    sk_sp<SkImage> image = this->refCachedImage();
    SkASSERT(image);
 
    if (static_cast<SkImage_Ganesh*>(image.get())
                ->surfaceMustCopyOnWrite(readSurfaceView.proxy())) {
        if (!fDevice->replaceBackingProxy(mode)) {
            return false;
        }
    } else if (kDiscard_ContentChangeMode == mode) {
        this->SkSurface_Ganesh::onDiscard();
    }
    return true;
}

onDiscard()

void SkSurface_Ganesh::onDiscard ( )

overridevirtual

Called as a performance hint when the Surface is allowed to make it's contents undefined.

Reimplemented from SkSurface_Base.

Definition at line 246 of file SkSurface_Ganesh.cpp.

{ fDevice->discard(); }

onDraw()

void SkSurface_Ganesh::onDraw ( SkCanvas *  canvas, SkScalar  x, SkScalar  y, const SkSamplingOptions &  sampling, const SkPaint *  paint  )

overridevirtual

Default implementation:

image = this->newImageSnapshot(); if (image) { image->draw(canvas, ...); image->unref(); }

Reimplemented from SkSurface_Base.

Definition at line 303 of file SkSurface_Ganesh.cpp.

                                                    {
    // If the dst is also GPU we try to not force a new image snapshot (by calling the base class
    // onDraw) since that may not always perform the copy-on-write optimization.
    auto tryDraw = [&] {
        auto surfaceContext = fDevice->recordingContext();
        auto canvasContext = GrAsDirectContext(canvas->recordingContext());
        if (!canvasContext) {
            return false;
        }
        if (canvasContext->priv().contextID() != surfaceContext->priv().contextID()) {
            return false;
        }
        GrSurfaceProxyView srcView = fDevice->readSurfaceView();
        if (!srcView.asTextureProxyRef()) {
            return false;
        }
        // Possibly we could skip making an image here if SkGpuDevice exposed a lower level way
        // of drawing a texture proxy.
        const SkImageInfo info = fDevice->imageInfo();
        sk_sp<SkImage> image = sk_make_sp<SkImage_Ganesh>(sk_ref_sp(canvasContext),
                                                          kNeedNewImageUniqueID,
                                                          std::move(srcView),
                                                          info.colorInfo());
        canvas->drawImage(image.get(), x, y, sampling, paint);
        return true;
    };
    if (!tryDraw()) {
        INHERITED::onDraw(canvas, x, y, sampling, paint);
    }
}

onGetRecordingContext()

GrRecordingContext * SkSurface_Ganesh::onGetRecordingContext ( ) const

overridevirtual

Reimplemented from SkSurface_Base.

Definition at line 77 of file SkSurface_Ganesh.cpp.

                                                                  {
    return fDevice->recordingContext();
}

onIsCompatible()

bool SkSurface_Ganesh::onIsCompatible ( const GrSurfaceCharacterization &  characterization ) const

overridevirtual

Reimplemented from SkSurface_Base.

Definition at line 338 of file SkSurface_Ganesh.cpp.

                                                                                             {
    auto direct = fDevice->recordingContext()->asDirectContext();
    if (!direct) {
        return false;
    }
 
    if (!characterization.isValid()) {
        return false;
    }
 
    if (characterization.vulkanSecondaryCBCompatible()) {
        return false;
    }
 
    SkImageInfo ii = fDevice->imageInfo();
    if (ii.colorType() == kUnknown_SkColorType) {
        return false;
    }
 
    GrSurfaceProxyView targetView = fDevice->readSurfaceView();
    // As long as the current state if the context allows for greater or equal resources,
    // we allow the DDL to be replayed.
    // DDL TODO: should we just remove the resource check and ignore the cache limits on playback?
    size_t maxResourceBytes = direct->getResourceCacheLimit();
 
    if (characterization.isTextureable()) {
        if (!targetView.asTextureProxy()) {
            // If the characterization was textureable we require the replay dest to also be
            // textureable. If the characterized surface wasn't textureable we allow the replay
            // dest to be textureable.
            return false;
        }
 
        if (characterization.isMipMapped() &&
            skgpu::Mipmapped::kNo == targetView.asTextureProxy()->mipmapped()) {
            // Fail if the DDL's surface was mipmapped but the replay surface is not.
            // Allow drawing to proceed if the DDL was not mipmapped but the replay surface is.
            return false;
        }
    }
 
    if (characterization.usesGLFBO0() != targetView.asRenderTargetProxy()->glRTFBOIDIs0()) {
        // FBO0-ness effects how MSAA and window rectangles work. If the characterization was
        // tagged as FBO0 it would never have been allowed to use window rectangles. If MSAA
        // was also never used then a DDL recorded with this characterization should be replayable
        // on a non-FBO0 surface.
        if (!characterization.usesGLFBO0() || characterization.sampleCount() > 1) {
            return false;
        }
    }
 
    GrBackendFormat format = targetView.asRenderTargetProxy()->backendFormat();
    int numSamples = targetView.asRenderTargetProxy()->numSamples();
    GrProtected isProtected = targetView.proxy()->isProtected();
 
    return characterization.contextInfo() &&
           characterization.contextInfo()->priv().matches(direct) &&
           characterization.cacheMaxResourceBytes() <= maxResourceBytes &&
           characterization.origin() == targetView.origin() &&
           characterization.backendFormat() == format && characterization.width() == ii.width() &&
           characterization.height() == ii.height() &&
           characterization.colorType() == ii.colorType() &&
           characterization.sampleCount() == numSamples &&
           SkColorSpace::Equals(characterization.colorSpace(), ii.colorInfo().colorSpace()) &&
           characterization.isProtected() == isProtected &&
           characterization.surfaceProps() == fDevice->surfaceProps();
}

onNewCanvas()

SkCanvas * SkSurface_Ganesh::onNewCanvas ( )

overridevirtual

Allocate a canvas that will draw into this surface. We will cache this canvas, to return the same object to the caller multiple times. We take ownership, and will call unref() on the canvas when we go out of scope.

Implements SkSurface_Base.

Definition at line 132 of file SkSurface_Ganesh.cpp.

{ return new SkCanvas(fDevice); }

onNewImageSnapshot()

sk_sp< SkImage > SkSurface_Ganesh::onNewImageSnapshot ( const SkIRect *  subset )

overridevirtual

Allocate an SkImage that represents the current contents of the surface. This needs to be able to outlive the surface itself (if need be), and must faithfully represent the current contents, even if the surface is changed after this called (e.g. it is drawn to via its canvas).

If a subset is specified, the the impl must make a copy, rather than try to wait on copy-on-write.

Reimplemented from SkSurface_Base.

Definition at line 147 of file SkSurface_Ganesh.cpp.

                                                                         {
    GrRenderTargetProxy* rtp = fDevice->targetProxy();
    if (!rtp) {
        return nullptr;
    }
 
    auto rContext = fDevice->recordingContext();
 
    GrSurfaceProxyView srcView = fDevice->readSurfaceView();
 
    skgpu::Budgeted budgeted = rtp->isBudgeted();
 
    if (subset || !srcView.asTextureProxy() || rtp->refsWrappedObjects()) {
        // If the original render target is a buffer originally created by the client, then we don't
        // want to ever retarget the SkSurface at another buffer we create. If the source is a
        // texture (and the image is not subsetted) we make a dual-proxied SkImage that will
        // attempt to share the backing store until the surface writes to the shared backing store
        // at which point it uses a copy.
        if (!subset && srcView.asTextureProxy()) {
            return SkImage_Ganesh::MakeWithVolatileSrc(
                    sk_ref_sp(rContext), srcView, fDevice->imageInfo().colorInfo());
        }
        auto rect = subset ? *subset : SkIRect::MakeSize(srcView.dimensions());
        skgpu::Mipmapped mipmapped = srcView.mipmapped();
        srcView = GrSurfaceProxyView::Copy(rContext,
                                           std::move(srcView),
                                           mipmapped,
                                           rect,
                                           SkBackingFit::kExact,
                                           budgeted,
                                           /*label=*/"SurfaceGpu_NewImageSnapshot");
    }
 
    const SkImageInfo info = fDevice->imageInfo();
    if (!srcView.asTextureProxy()) {
        return nullptr;
    }
    // The surfaceDrawContext coming out of SkGpuDevice should always be exact and the
    // above copy creates a kExact surfaceContext.
    SkASSERT(srcView.proxy()->priv().isExact());
    return sk_make_sp<SkImage_Ganesh>(
            sk_ref_sp(rContext), kNeedNewImageUniqueID, std::move(srcView), info.colorInfo());
}

onNewSurface()

sk_sp< SkSurface > SkSurface_Ganesh::onNewSurface ( const SkImageInfo &  info )

overridevirtual

Implements SkSurface_Base.

Definition at line 134 of file SkSurface_Ganesh.cpp.

                                                                       {
    GrSurfaceProxyView targetView = fDevice->readSurfaceView();
    int sampleCount = targetView.asRenderTargetProxy()->numSamples();
    GrSurfaceOrigin origin = targetView.origin();
    // TODO: Make caller specify this (change virtual signature of onNewSurface).
    static const skgpu::Budgeted kBudgeted = skgpu::Budgeted::kNo;
 
    bool isProtected = targetView.asRenderTargetProxy()->isProtected() == GrProtected::kYes;
    return SkSurfaces::RenderTarget(
            fDevice->recordingContext(), kBudgeted, info, sampleCount, origin, &this->props(),
            /* shouldCreateWithMips= */ false, isProtected);
}

onWait()

bool SkSurface_Ganesh::onWait ( int  numSemaphores, const GrBackendSemaphore *  waitSemaphores, bool  deleteSemaphoresAfterWait  )

overridevirtual

Caused the current backend 3D API to wait on the passed in semaphores before executing new commands on the gpu. Any previously submitting commands will not be blocked by these semaphores.

Reimplemented from SkSurface_Base.

Definition at line 250 of file SkSurface_Ganesh.cpp.

                                                              {
    return fDevice->wait(numSemaphores, waitSemaphores, deleteSemaphoresAfterWait);
}

onWritePixels()

void SkSurface_Ganesh::onWritePixels ( const SkPixmap &  src, int  x, int  y  )

overridevirtual

Implements SkSurface_Base.

Definition at line 191 of file SkSurface_Ganesh.cpp.

                                                                      {
    fDevice->writePixels(src, x, y);
}

replaceBackendTexture()

bool SkSurface_Ganesh::replaceBackendTexture ( const GrBackendTexture &  backendTexture, GrSurfaceOrigin  origin, ContentChangeMode  mode, TextureReleaseProc  , ReleaseContext    )

overridevirtual

If the surface was made via MakeFromBackendTexture then it's backing texture may be substituted with a different texture. The contents of the previous backing texture are copied into the new texture. SkCanvas state is preserved. The original sample count is used. The GrBackendFormat and dimensions of replacement texture must match that of the original.

Upon success textureReleaseProc is called when it is safe to delete the texture in the backend API (accounting only for use of the texture by this surface). If SkSurface creation fails textureReleaseProc is called before this function returns.

Parameters

backendTexture	the new backing texture for the surface
mode	Retain or discard current Content
TextureReleaseProc	function called when texture can be released
ReleaseContext	state passed to textureReleaseProc

Reimplemented from SkSurface_Base.

Definition at line 468 of file SkSurface_Ganesh.cpp.

                                                                            {
    auto releaseHelper = skgpu::RefCntedCallback::Make(releaseProc, releaseContext);
 
    auto rContext = fDevice->recordingContext();
    if (rContext->abandoned()) {
        return false;
    }
    if (!backendTexture.isValid()) {
        return false;
    }
    if (backendTexture.width() != this->width() || backendTexture.height() != this->height()) {
        return false;
    }
    auto* oldRTP = fDevice->targetProxy();
    auto oldProxy = sk_ref_sp(oldRTP->asTextureProxy());
    if (!oldProxy) {
        return false;
    }
    auto* oldTexture = oldProxy->peekTexture();
    if (!oldTexture) {
        return false;
    }
    if (!oldTexture->resourcePriv().refsWrappedObjects()) {
        return false;
    }
    if (oldTexture->backendFormat() != backendTexture.getBackendFormat()) {
        return false;
    }
    if (oldTexture->getBackendTexture().isSameTexture(backendTexture)) {
        return false;
    }
    SkASSERT(oldTexture->asRenderTarget());
    int sampleCnt = oldTexture->asRenderTarget()->numSamples();
    GrColorType grColorType = SkColorTypeToGrColorType(this->getCanvas()->imageInfo().colorType());
    if (!validate_backend_texture(
                rContext->priv().caps(), backendTexture, sampleCnt, grColorType, true)) {
        return false;
    }
 
    sk_sp<SkColorSpace> colorSpace = fDevice->imageInfo().refColorSpace();
 
    SkASSERT(sampleCnt > 0);
    sk_sp<GrTextureProxy> proxy(rContext->priv().proxyProvider()->wrapRenderableBackendTexture(
            backendTexture,
            sampleCnt,
            kBorrow_GrWrapOwnership,
            GrWrapCacheable::kNo,
            std::move(releaseHelper)));
    if (!proxy) {
        return false;
    }
 
    return fDevice->replaceBackingProxy(mode,
                                        sk_ref_sp(proxy->asRenderTargetProxy()),
                                        grColorType,
                                        std::move(colorSpace),
                                        origin,
                                        this->props());
}

resolveMSAA()

void SkSurface_Ganesh::resolveMSAA

(

)

Definition at line 248 of file SkSurface_Ganesh.cpp.

{ fDevice->resolveMSAA(); }

type()

SkSurface_Base::Type SkSurface_Ganesh::type ( ) const

inlineoverridevirtual

Reimplemented from SkSurface_Base.

Definition at line 54 of file SkSurface_Ganesh.h.

{ return SkSurface_Base::Type::kGanesh; }

---

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

• third_party/skia/src/gpu/ganesh/surface/SkSurface_Ganesh.h
• third_party/skia/src/gpu/ganesh/surface/SkSurface_Ganesh.cpp