#include <RecordingPriv.h>

Public Member Functions
bool	hasVolatileLazyProxies () const

bool	instantiateVolatileLazyProxies (ResourceProvider *)

void	deinstantiateVolatileLazyProxies ()

bool	hasNonVolatileLazyProxies () const

bool	instantiateNonVolatileLazyProxies (ResourceProvider *)

void	setFailureResultForFinishedProcs ()

bool	addCommands (Context , CommandBuffer , Surface *targetSurface, SkIVector targetTranslation)

void	addResourceRef (sk_sp< Resource > resource)

void	addTask (sk_sp< Task > task)

void	addTasks (TaskList &&tasks)

uint32_t	recorderID () const

uint32_t	uniqueID () const

Friends
class	Recording

Detailed Description

Definition at line 19 of file RecordingPriv.h.

Member Function Documentation

◆ addCommands()

bool skgpu::graphite::RecordingPriv::addCommands	(	Context *	context,
		CommandBuffer *	commandBuffer,
		Surface *	targetSurface,
		SkIVector	targetTranslation
	)

Definition at line 124 of file Recording.cpp.

                                                             {
    AutoDeinstantiateTextureProxy autoDeinstantiateTargetProxy(
            fRecording->fTargetProxyData ? fRecording->fTargetProxyData->lazyProxy() : nullptr);
 
    const Texture* replayTarget = nullptr;
    ResourceProvider* resourceProvider = context->priv().resourceProvider();
    SkASSERT(!SkToBool(fRecording->fTargetProxyData) || SkToBool(targetSurface));
    if (fRecording->fTargetProxyData) {
        if (!targetSurface) {
            SKGPU_LOG_E("No surface provided to instantiate target texture proxy.");
            return false;
        }
        TextureProxy* surfaceTexture = targetSurface->backingTextureProxy();
        if (!surfaceTexture->instantiate(resourceProvider)) {
            SKGPU_LOG_E("Could not instantiate target texture proxy.");
            return false;
        }
        if (!fRecording->fTargetProxyData->lazyInstantiate(resourceProvider,
                                                           surfaceTexture->refTexture())) {
            SKGPU_LOG_E("Could not instantiate deferred texture proxy.");
            return false;
        }
        replayTarget = surfaceTexture->texture();
    }
 
    for (size_t i = 0; i < fRecording->fExtraResourceRefs.size(); ++i) {
        commandBuffer->trackResource(fRecording->fExtraResourceRefs[i]);
    }
 
    // There's no need to differentiate kSuccess and kDiscard at the root list level; if every task
    // is discarded, the Recording will automatically be a no-op on replay while still correctly
    // notifying any finish procs the client may have added.
    if (fRecording->fRootTaskList->addCommands(
                context, commandBuffer, {replayTarget, targetTranslation}) == Task::Status::kFail) {
        return false;
    }
    for (int i = 0; i < fRecording->fFinishedProcs.size(); ++i) {
        commandBuffer->addFinishedProc(std::move(fRecording->fFinishedProcs[i]));
    }
    fRecording->fFinishedProcs.clear();
 
    return true;
}

◆ addResourceRef()

void skgpu::graphite::RecordingPriv::addResourceRef ( sk_sp< Resource > resource )

Definition at line 171 of file Recording.cpp.

                                                           {
    fRecording->fExtraResourceRefs.push_back(std::move(resource));
}

◆ addTask()

void skgpu::graphite::RecordingPriv::addTask ( sk_sp< Task > task )

Definition at line 175 of file Recording.cpp.

                                            {
    fRecording->fRootTaskList->add(std::move(task));
}

◆ addTasks()

void skgpu::graphite::RecordingPriv::addTasks ( TaskList && tasks )

Definition at line 179 of file Recording.cpp.

                                             {
    fRecording->fRootTaskList->add(std::move(tasks));
}

◆ deinstantiateVolatileLazyProxies()

void skgpu::graphite::RecordingPriv::deinstantiateVolatileLazyProxies ( )

Definition at line 106 of file Recording.cpp.

                                                     {
    if (!this->hasVolatileLazyProxies()) {
        return;
    }
 
    for (const auto& proxy : fRecording->fVolatileLazyProxies) {
        SkASSERT(proxy->isVolatile());
        proxy->deinstantiate();
    }
}

◆ hasNonVolatileLazyProxies()

bool skgpu::graphite::RecordingPriv::hasNonVolatileLazyProxies ( ) const

Definition at line 71 of file Recording.cpp.

                                                    {
    return !fRecording->fNonVolatileLazyProxies.empty();
}

◆ hasVolatileLazyProxies()

bool skgpu::graphite::RecordingPriv::hasVolatileLazyProxies ( ) const

Definition at line 90 of file Recording.cpp.

                                                 {
    return !fRecording->fVolatileLazyProxies.empty();
}

◆ instantiateNonVolatileLazyProxies()

bool skgpu::graphite::RecordingPriv::instantiateNonVolatileLazyProxies ( ResourceProvider * resourceProvider )

Definition at line 75 of file Recording.cpp.

                                                                                        {
    SkASSERT(this->hasNonVolatileLazyProxies());
 
    for (const auto& proxy : fRecording->fNonVolatileLazyProxies) {
        if (!proxy->lazyInstantiate(resourceProvider)) {
            return false;
        }
    }
 
    // Note: once all the lazy proxies have been instantiated, that's it - there are no more
    // chances to instantiate.
    fRecording->fNonVolatileLazyProxies.clear();
    return true;
}

◆ instantiateVolatileLazyProxies()

bool skgpu::graphite::RecordingPriv::instantiateVolatileLazyProxies ( ResourceProvider * resourceProvider )

Definition at line 94 of file Recording.cpp.

                                                                                     {
    SkASSERT(this->hasVolatileLazyProxies());
 
    for (const auto& proxy : fRecording->fVolatileLazyProxies) {
        if (!proxy->lazyInstantiate(resourceProvider)) {
            return false;
        }
    }
 
    return true;
}

◆ recorderID()

uint32_t skgpu::graphite::RecordingPriv::recorderID ( ) const

inline

Definition at line 39 of file RecordingPriv.h.

39{ return fRecording->fRecorderID; }

◆ setFailureResultForFinishedProcs()

void skgpu::graphite::RecordingPriv::setFailureResultForFinishedProcs ( )

Definition at line 117 of file Recording.cpp.

                                                     {
    for (int i = 0; i < fRecording->fFinishedProcs.size(); ++i) {
        fRecording->fFinishedProcs[i]->setFailureResult();
    }
    fRecording->fFinishedProcs.clear();
}

◆ uniqueID()

uint32_t skgpu::graphite::RecordingPriv::uniqueID ( ) const

inline

Definition at line 40 of file RecordingPriv.h.

40{ return fRecording->fUniqueID; }

Friends And Related Function Documentation

◆ Recording

friend class Recording

friend

Definition at line 59 of file RecordingPriv.h.

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

third_party/skia/src/gpu/graphite/RecordingPriv.h
third_party/skia/src/gpu/graphite/Recording.cpp

Public Member Functions

Friends