#include <CopyTask.h>

Inheritance diagram for skgpu::graphite::CopyTextureToTextureTask:

Public Member Functions
	~CopyTextureToTextureTask () override

Status	prepareResources (ResourceProvider , ScratchResourceManager , const RuntimeEffectDictionary *) override

Status	addCommands (Context , CommandBuffer , ReplayTargetData) override

virtual Status	prepareResources (ResourceProvider , ScratchResourceManager , const RuntimeEffectDictionary *)=0

virtual Status	addCommands (Context , CommandBuffer , ReplayTargetData)=0

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< CopyTextureToTextureTask >	Make (sk_sp< TextureProxy > srcProxy, SkIRect srcRect, sk_sp< TextureProxy > dstProxy, SkIPoint dstPoint, int dstLevel=0)

Additional Inherited Members
Public Types inherited from skgpu::graphite::Task
enum class	Status { kSuccess , kDiscard , kFail }

Detailed Description

Definition at line 84 of file CopyTask.h.

Constructor & Destructor Documentation

◆ ~CopyTextureToTextureTask()

skgpu::graphite::CopyTextureToTextureTask::~CopyTextureToTextureTask ( )

override

Definition at line 149 of file CopyTask.cpp.

149{}

Member Function Documentation

◆ addCommands()

Task::Status skgpu::graphite::CopyTextureToTextureTask::addCommands	(	Context *	,
		CommandBuffer *	commandBuffer,
		ReplayTargetData
	)

overridevirtual

Implements skgpu::graphite::Task.

Definition at line 180 of file CopyTask.cpp.

                                                                     {
    // prepareResources() doesn't instantiate the source assuming that a prior task will have do so
    // as part of initializing the texture contents.
    SkASSERT(fSrcProxy->isInstantiated());
    if (commandBuffer->copyTextureToTexture(fSrcProxy->refTexture(),
                                            fSrcRect,
                                            fDstProxy->refTexture(),
                                            fDstPoint,
                                            fDstLevel)) {
        // TODO(b/332681367): The calling context should be able to specify whether or not this copy
        // is a repeatable operation (e.g. dst readback copy for blending) or one time (e.g. client
        // asked for a copy of an image or surface).
        return Status::kSuccess;
    } else {
        return Status::kFail;
    }
}

◆ Make()

sk_sp< CopyTextureToTextureTask > skgpu::graphite::CopyTextureToTextureTask::Make	(	sk_sp< TextureProxy >	srcProxy,
		SkIRect	srcRect,
		sk_sp< TextureProxy >	dstProxy,
		SkIPoint	dstPoint,
		int	dstLevel = `0`
	)

static

Definition at line 123 of file CopyTask.cpp.

                                                                             {
    if (!srcProxy || !dstProxy) {
        return nullptr;
    }
    return sk_sp<CopyTextureToTextureTask>(new CopyTextureToTextureTask(std::move(srcProxy),
                                                                        srcRect,
                                                                        std::move(dstProxy),
                                                                        dstPoint,
                                                                        dstLevel));
}

◆ prepareResources()

Task::Status skgpu::graphite::CopyTextureToTextureTask::prepareResources	(	ResourceProvider *	resourceProvider,
		ScratchResourceManager *	,
		const RuntimeEffectDictionary *
	)

overridevirtual

Implements skgpu::graphite::Task.

Definition at line 151 of file CopyTask.cpp.

                                                                                        {
    // Do not instantiate the src proxy. If the source texture hasn't been instantiated yet, it
    // means there was no prior task that could have initialized its contents so propagating the
    // undefined contents to the dst does not make sense.
    // TODO(b/333729316): Assert that fSrcProxy is instantiated or lazy; right now it may not be
    // instantatiated if this is a dst readback copy for a scratch Device. In that case, a
    // RenderPassTask will immediately follow this copy task and instantiate the source proxy so
    // that addCommands() has a texture to operate on. That said, the texture's contents will be
    // undefined when the copy is executed ideally it just shouldn't happen.
 
    // TODO: The copy is also a consumer of the source, so it should participate in returning
    // scratch resources like RenderPassTask does. For now, though, all copy tasks side step reuse
    // entirely and they cannot participate until they've been moved into scoping tasks like
    // DrawTask first. In particular, for texture-to-texture copies, they should be scoped to not
    // invoke pending listeners for a subsequent RenderPassTask.
 
    // TODO: Use the scratch resource manager to instantiate fDstProxy, although the details of when
    // that texture can be returned need to be worked out. While brittle, all current use cases
    // of scratch texture-to-texture copies have the dst used immediately by the next task, so it
    // could just add a pending listener that returns the texture w/o any read counting.
    if (!TextureProxy::InstantiateIfNotLazy(resourceProvider, fDstProxy.get())) {
        SKGPU_LOG_E("Could not instantiate dst texture proxy for CopyTextureToTextureTask!");
        return Status::kFail;
    }
    return Status::kSuccess;
}

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

third_party/skia/src/gpu/graphite/task/CopyTask.h
third_party/skia/src/gpu/graphite/task/CopyTask.cpp

Public Member Functions

Static Public Member Functions