GrDrawingManager Class Reference

#include <GrDrawingManager.h>

Public Types
using	PathRenderer = skgpu::ganesh::PathRenderer
using	PathRendererChain = skgpu::ganesh::PathRendererChain

Public Member Functions
	~GrDrawingManager ()
void	freeGpuResources ()
sk_sp< skgpu::ganesh::OpsTask >	newOpsTask (GrSurfaceProxyView, sk_sp< GrArenas > arenas)
void	addAtlasTask (sk_sp< GrRenderTask > atlasTask, GrRenderTask *previousAtlasTask)
GrTextureResolveRenderTask *	newTextureResolveRenderTaskBefore (const GrCaps &)
void	newTextureResolveRenderTask (sk_sp< GrSurfaceProxy > proxy, GrSurfaceProxy::ResolveFlags, const GrCaps &)
void	newWaitRenderTask (const sk_sp< GrSurfaceProxy > &proxy, std::unique_ptr< std::unique_ptr< GrSemaphore >[]>, int numSemaphores)
void	newTransferFromRenderTask (const sk_sp< GrSurfaceProxy > &srcProxy, const SkIRect &srcRect, GrColorType surfaceColorType, GrColorType dstColorType, sk_sp< GrGpuBuffer > dstBuffer, size_t dstOffset)
sk_sp< GrRenderTask >	newCopyRenderTask (sk_sp< GrSurfaceProxy > dst, SkIRect dstRect, const sk_sp< GrSurfaceProxy > &src, SkIRect srcRect, GrSamplerState::Filter filter, GrSurfaceOrigin)
void	newBufferTransferTask (sk_sp< GrGpuBuffer > src, size_t srcOffset, sk_sp< GrGpuBuffer > dst, size_t dstOffset, size_t size)
void	newBufferUpdateTask (sk_sp< SkData > src, sk_sp< GrGpuBuffer > dst, size_t dstOffset)
bool	newWritePixelsTask (sk_sp< GrSurfaceProxy > dst, SkIRect rect, GrColorType srcColorType, GrColorType dstColorType, const GrMipLevel[], int levelCount)
GrRecordingContext *	getContext ()
PathRenderer *	getPathRenderer (const PathRenderer::CanDrawPathArgs &, bool allowSW, PathRendererChain::DrawType, PathRenderer::StencilSupport *=nullptr)
PathRenderer *	getSoftwarePathRenderer ()
skgpu::ganesh::AtlasPathRenderer *	getAtlasPathRenderer ()
PathRenderer *	getTessellationPathRenderer ()
void	flushIfNecessary ()
GrSemaphoresSubmitted	flushSurfaces (SkSpan< GrSurfaceProxy * >, SkSurfaces::BackendSurfaceAccess, const GrFlushInfo &, const skgpu::MutableTextureState *newState)
void	addOnFlushCallbackObject (GrOnFlushCallbackObject *)
GrRenderTask *	getLastRenderTask (const GrSurfaceProxy *) const
skgpu::ganesh::OpsTask *	getLastOpsTask (const GrSurfaceProxy *) const
void	setLastRenderTask (const GrSurfaceProxy *, GrRenderTask *)
void	moveRenderTasksToDDL (GrDeferredDisplayList *ddl)
void	createDDLTask (sk_sp< const GrDeferredDisplayList >, sk_sp< GrRenderTargetProxy > newDest)
bool	flush (SkSpan< GrSurfaceProxy * > proxies, SkSurfaces::BackendSurfaceAccess access, const GrFlushInfo &, const skgpu::MutableTextureState *newState)

Static Public Member Functions
static bool	ProgramUnitTest (GrDirectContext *, int maxStages, int maxLevels)

Friends
class	GrOnFlushResourceProvider
class	GrRecordingContext

Detailed Description

Definition at line 46 of file GrDrawingManager.h.

Member Typedef Documentation

PathRenderer

using GrDrawingManager::PathRenderer = skgpu::ganesh::PathRenderer

Definition at line 137 of file GrDrawingManager.h.

PathRendererChain

using GrDrawingManager::PathRendererChain = skgpu::ganesh::PathRendererChain

Definition at line 138 of file GrDrawingManager.h.

Constructor & Destructor Documentation

~GrDrawingManager()

GrDrawingManager::~GrDrawingManager

(

)

Definition at line 64 of file GrDrawingManager.cpp.

                                    {
    this->closeAllTasks();
    this->removeRenderTasks();
}

Member Function Documentation

addAtlasTask()

void GrDrawingManager::addAtlasTask	(	sk_sp< GrRenderTask >	atlasTask,
		GrRenderTask *	previousAtlasTask
	)

Definition at line 701 of file GrDrawingManager.cpp.

                                                                     {
    SkDEBUGCODE(this->validate());
    SkASSERT(fContext);
 
    if (previousAtlasTask) {
        previousAtlasTask->makeClosed(fContext);
        for (GrRenderTask* previousAtlasUser : previousAtlasTask->dependents()) {
            // Make the new atlas depend on everybody who used the old atlas, and close their tasks.
            // This guarantees that the previous atlas is totally out of service before we render
            // the next one, meaning there is only ever one atlas active at a time and that they can
            // all share the same texture.
            atlasTask->addDependency(previousAtlasUser);
            previousAtlasUser->makeClosed(fContext);
            if (previousAtlasUser == fActiveOpsTask) {
                fActiveOpsTask = nullptr;
            }
        }
    }
 
    atlasTask->setFlag(GrRenderTask::kAtlas_Flag);
    this->insertTaskBeforeLast(std::move(atlasTask));
 
    SkDEBUGCODE(this->validate());
}

addOnFlushCallbackObject()

void GrDrawingManager::addOnFlushCallbackObject

(

GrOnFlushCallbackObject *

onFlushCBObject

)

Definition at line 534 of file GrDrawingManager.cpp.

                                                                                        {
    fOnFlushCBObjects.push_back(onFlushCBObject);
}

createDDLTask()

void GrDrawingManager::createDDLTask	(	sk_sp< const GrDeferredDisplayList >	ddl,
		sk_sp< GrRenderTargetProxy >	newDest
	)

Definition at line 596 of file GrDrawingManager.cpp.

                                                                         {
    SkDEBUGCODE(this->validate());
 
    if (fActiveOpsTask) {
        // This is a temporary fix for the partial-MDB world. In that world we're not
        // reordering so ops that (in the single opsTask world) would've just glommed onto the
        // end of the single opsTask but referred to a far earlier RT need to appear in their
        // own opsTask.
        fActiveOpsTask->makeClosed(fContext);
        fActiveOpsTask = nullptr;
    }
 
    // Propagate the DDL proxy's state information to the replay target.
    if (ddl->priv().targetProxy()->isMSAADirty()) {
        auto nativeRect = GrNativeRect::MakeIRectRelativeTo(
                ddl->characterization().origin(),
                ddl->priv().targetProxy()->backingStoreDimensions().height(),
                ddl->priv().targetProxy()->msaaDirtyRect());
        newDest->markMSAADirty(nativeRect);
    }
    GrTextureProxy* newTextureProxy = newDest->asTextureProxy();
    if (newTextureProxy && skgpu::Mipmapped::kYes == newTextureProxy->mipmapped()) {
        newTextureProxy->markMipmapsDirty();
    }
 
    // Here we jam the proxy that backs the current replay SkSurface into the LazyProxyData.
    // The lazy proxy that references it (in the DDL opsTasks) will then steal its GrTexture.
    ddl->fLazyProxyData->fReplayDest = newDest.get();
 
    // Add a task to handle drawing and lifetime management of the DDL.
    SkDEBUGCODE(auto ddlTask =) this->appendTask(sk_make_sp<GrDDLTask>(this,
                                                                       std::move(newDest),
                                                                       std::move(ddl)));
    SkASSERT(ddlTask->isClosed());
 
    SkDEBUGCODE(this->validate());
}

flush()

bool GrDrawingManager::flush	(	SkSpan< GrSurfaceProxy * >	proxies,
		SkSurfaces::BackendSurfaceAccess	access,
		const GrFlushInfo &	info,
		const skgpu::MutableTextureState *	newState
	)

Definition at line 87 of file GrDrawingManager.cpp.

                                                                       {
    GR_CREATE_TRACE_MARKER_CONTEXT("GrDrawingManager", "flush", fContext);
 
    if (fFlushing || this->wasAbandoned()) {
        if (info.fSubmittedProc) {
            info.fSubmittedProc(info.fSubmittedContext, false);
        }
        if (info.fFinishedProc) {
            info.fFinishedProc(info.fFinishedContext);
        }
        return false;
    }
 
    SkDEBUGCODE(this->validate());
 
    // As of now we only short-circuit if we got an explicit list of surfaces to flush.
    if (!proxies.empty() && !info.fNumSemaphores && !info.fFinishedProc &&
        access == SkSurfaces::BackendSurfaceAccess::kNoAccess && !newState) {
        bool allUnused = std::all_of(proxies.begin(), proxies.end(), [&](GrSurfaceProxy* proxy) {
            bool used = std::any_of(fDAG.begin(), fDAG.end(), [&](auto& task) {
                return task && task->isUsed(proxy);
            });
            return !used;
        });
        if (allUnused) {
            if (info.fSubmittedProc) {
                info.fSubmittedProc(info.fSubmittedContext, true);
            }
            return false;
        }
    }
 
    auto dContext = fContext->asDirectContext();
    SkASSERT(dContext);
    dContext->priv().clientMappedBufferManager()->process();
 
    GrGpu* gpu = dContext->priv().getGpu();
    // We have a non abandoned and direct GrContext. It must have a GrGpu.
    SkASSERT(gpu);
 
    fFlushing = true;
 
    auto resourceProvider = dContext->priv().resourceProvider();
    auto resourceCache = dContext->priv().getResourceCache();
 
    // Semi-usually the GrRenderTasks are already closed at this point, but sometimes Ganesh needs
    // to flush mid-draw. In that case, the SkGpuDevice's opsTasks won't be closed but need to be
    // flushed anyway. Closing such opsTasks here will mean new ones will be created to replace them
    // if the SkGpuDevice(s) write to them again.
    this->closeAllTasks();
    fActiveOpsTask = nullptr;
 
    this->sortTasks();
 
    if (!fCpuBufferCache) {
        // We cache more buffers when the backend is using client side arrays. Otherwise, we
        // expect each pool will use a CPU buffer as a staging buffer before uploading to a GPU
        // buffer object. Each pool only requires one staging buffer at a time.
        int maxCachedBuffers = fContext->priv().caps()->preferClientSideDynamicBuffers() ? 2 : 6;
        fCpuBufferCache = GrBufferAllocPool::CpuBufferCache::Make(maxCachedBuffers);
    }
 
    GrOpFlushState flushState(gpu, resourceProvider, &fTokenTracker, fCpuBufferCache);
 
    GrOnFlushResourceProvider onFlushProvider(this);
 
    // Prepare any onFlush op lists (e.g. atlases).
    bool preFlushSuccessful = true;
    for (GrOnFlushCallbackObject* onFlushCBObject : fOnFlushCBObjects) {
        preFlushSuccessful &= onFlushCBObject->preFlush(&onFlushProvider);
    }
 
    bool cachePurgeNeeded = false;
 
    if (preFlushSuccessful) {
        bool usingReorderedDAG = false;
        GrResourceAllocator resourceAllocator(dContext);
        if (fReduceOpsTaskSplitting) {
            usingReorderedDAG = this->reorderTasks(&resourceAllocator);
            if (!usingReorderedDAG) {
                resourceAllocator.reset();
            }
        }
 
#if 0
        // Enable this to print out verbose GrOp information
        SkDEBUGCODE(SkDebugf("RenderTasks (%d):\n", fDAG.count()));
        for (const auto& task : fDAG) {
            SkDEBUGCODE(task->dump(/* printDependencies */ true);)
        }
#endif
 
        if (!resourceAllocator.failedInstantiation()) {
            if (!usingReorderedDAG) {
                for (const auto& task : fDAG) {
                    SkASSERT(task);
                    task->gatherProxyIntervals(&resourceAllocator);
                }
                resourceAllocator.planAssignment();
            }
            resourceAllocator.assign();
        }
 
        cachePurgeNeeded = !resourceAllocator.failedInstantiation() &&
                           this->executeRenderTasks(&flushState);
    }
    this->removeRenderTasks();
 
    gpu->executeFlushInfo(proxies, access, info, newState);
 
    // Give the cache a chance to purge resources that become purgeable due to flushing.
    if (cachePurgeNeeded) {
        resourceCache->purgeAsNeeded();
        cachePurgeNeeded = false;
    }
    for (GrOnFlushCallbackObject* onFlushCBObject : fOnFlushCBObjects) {
        onFlushCBObject->postFlush(fTokenTracker.nextFlushToken());
        cachePurgeNeeded = true;
    }
    if (cachePurgeNeeded) {
        resourceCache->purgeAsNeeded();
    }
    fFlushing = false;
 
    return true;
}

flushIfNecessary()

void GrDrawingManager::flushIfNecessary

(

)

Definition at line 1055 of file GrDrawingManager.cpp.

                                        {
    auto direct = fContext->asDirectContext();
    if (!direct) {
        return;
    }
 
    auto resourceCache = direct->priv().getResourceCache();
    if (resourceCache && resourceCache->requestsFlush()) {
        if (this->flush({}, SkSurfaces::BackendSurfaceAccess::kNoAccess, GrFlushInfo(), nullptr)) {
            this->submitToGpu(GrSyncCpu::kNo);
        }
        resourceCache->purgeAsNeeded();
    }
}

flushSurfaces()

GrSemaphoresSubmitted GrDrawingManager::flushSurfaces	(	SkSpan< GrSurfaceProxy * >	proxies,
		SkSurfaces::BackendSurfaceAccess	access,
		const GrFlushInfo &	info,
		const skgpu::MutableTextureState *	newState
	)

Definition at line 497 of file GrDrawingManager.cpp.

                                                                                                {
    if (this->wasAbandoned()) {
        if (info.fSubmittedProc) {
            info.fSubmittedProc(info.fSubmittedContext, false);
        }
        if (info.fFinishedProc) {
            info.fFinishedProc(info.fFinishedContext);
        }
        return GrSemaphoresSubmitted::kNo;
    }
    SkDEBUGCODE(this->validate());
 
    auto direct = fContext->asDirectContext();
    SkASSERT(direct);
    GrGpu* gpu = direct->priv().getGpu();
    // We have a non abandoned and direct GrContext. It must have a GrGpu.
    SkASSERT(gpu);
 
    // TODO: It is important to upgrade the drawingmanager to just flushing the
    // portion of the DAG required by 'proxies' in order to restore some of the
    // semantics of this method.
    bool didFlush = this->flush(proxies, access, info, newState);
    for (GrSurfaceProxy* proxy : proxies) {
        resolve_and_mipmap(gpu, proxy);
    }
 
    SkDEBUGCODE(this->validate());
 
    if (!didFlush || (!direct->priv().caps()->backendSemaphoreSupport() && info.fNumSemaphores)) {
        return GrSemaphoresSubmitted::kNo;
    }
    return GrSemaphoresSubmitted::kYes;
}

freeGpuResources()

void GrDrawingManager::freeGpuResources

(

)

Definition at line 73 of file GrDrawingManager.cpp.

                                        {
    for (int i = fOnFlushCBObjects.size() - 1; i >= 0; --i) {
        if (!fOnFlushCBObjects[i]->retainOnFreeGpuResources()) {
            // it's safe to just do this because we're iterating in reverse
            fOnFlushCBObjects.removeShuffle(i);
        }
    }
 
    // a path renderer may be holding onto resources
    fPathRendererChain = nullptr;
    fSoftwarePathRenderer = nullptr;
}

getAtlasPathRenderer()

skgpu::ganesh::AtlasPathRenderer * GrDrawingManager::getAtlasPathRenderer

(

)

Definition at line 1039 of file GrDrawingManager.cpp.

                                                                     {
    if (!fPathRendererChain) {
        fPathRendererChain = std::make_unique<PathRendererChain>(fContext,
                                                                 fOptionsForPathRendererChain);
    }
    return fPathRendererChain->getAtlasPathRenderer();
}

getContext()

GrRecordingContext * GrDrawingManager::getContext ( )

inline

Definition at line 135 of file GrDrawingManager.h.

{ return fContext; }

getLastOpsTask()

skgpu::ganesh::OpsTask * GrDrawingManager::getLastOpsTask

(

const GrSurfaceProxy *

proxy

)

const

Definition at line 566 of file GrDrawingManager.cpp.

                                                                                      {
    GrRenderTask* task = this->getLastRenderTask(proxy);
    return task ? task->asOpsTask() : nullptr;
}

getLastRenderTask()

GrRenderTask * GrDrawingManager::getLastRenderTask

(

const GrSurfaceProxy *

proxy

)

const

Definition at line 561 of file GrDrawingManager.cpp.

                                                                                   {
    auto entry = fLastRenderTasks.find(proxy->uniqueID().asUInt());
    return entry ? *entry : nullptr;
}

getPathRenderer()

skgpu::ganesh::PathRenderer * GrDrawingManager::getPathRenderer	(	const PathRenderer::CanDrawPathArgs &	args,
		bool	allowSW,
		PathRendererChain::DrawType	drawType,
		PathRenderer::StencilSupport *	stencilSupport = nullptr
	)

Definition at line 1003 of file GrDrawingManager.cpp.

                                                    {
    if (!fPathRendererChain) {
        fPathRendererChain =
                std::make_unique<PathRendererChain>(fContext, fOptionsForPathRendererChain);
    }
 
    auto pr = fPathRendererChain->getPathRenderer(args, drawType, stencilSupport);
    if (!pr && allowSW) {
        auto swPR = this->getSoftwarePathRenderer();
        if (PathRenderer::CanDrawPath::kNo != swPR->canDrawPath(args)) {
            pr = swPR;
        }
    }
 
#if GR_PATH_RENDERER_SPEW
    if (pr) {
        SkDebugf("getPathRenderer: %s\n", pr->name());
    }
#endif
 
    return pr;
}

getSoftwarePathRenderer()

skgpu::ganesh::PathRenderer * GrDrawingManager::getSoftwarePathRenderer

(

)

Definition at line 1030 of file GrDrawingManager.cpp.

                                                                   {
    if (!fSoftwarePathRenderer) {
        fSoftwarePathRenderer.reset(new skgpu::ganesh::SoftwarePathRenderer(
                fContext->priv().proxyProvider(),
                fOptionsForPathRendererChain.fAllowPathMaskCaching));
    }
    return fSoftwarePathRenderer.get();
}

getTessellationPathRenderer()

skgpu::ganesh::PathRenderer * GrDrawingManager::getTessellationPathRenderer

(

)

Definition at line 1047 of file GrDrawingManager.cpp.

                                                                       {
    if (!fPathRendererChain) {
        fPathRendererChain = std::make_unique<PathRendererChain>(fContext,
                                                                 fOptionsForPathRendererChain);
    }
    return fPathRendererChain->getTessellationPathRenderer();
}

moveRenderTasksToDDL()

void GrDrawingManager::moveRenderTasksToDDL

(

GrDeferredDisplayList *

ddl

)

Definition at line 571 of file GrDrawingManager.cpp.

                                                                      {
    SkDEBUGCODE(this->validate());
 
    // no renderTask should receive a new command after this
    this->closeAllTasks();
    fActiveOpsTask = nullptr;
 
    this->sortTasks();
 
    fDAG.swap(ddl->fRenderTasks);
    SkASSERT(fDAG.empty());
    fReorderBlockerTaskIndices.clear();
 
    for (auto& renderTask : ddl->fRenderTasks) {
        renderTask->disown(this);
        renderTask->prePrepare(fContext);
    }
 
    ddl->fArenas = std::move(fContext->priv().detachArenas());
 
    fContext->priv().detachProgramData(&ddl->fProgramData);
 
    SkDEBUGCODE(this->validate());
}

newBufferTransferTask()

void GrDrawingManager::newBufferTransferTask	(	sk_sp< GrGpuBuffer >	src,
		size_t	srcOffset,
		sk_sp< GrGpuBuffer >	dst,
		size_t	dstOffset,
		size_t	size
	)

Definition at line 847 of file GrDrawingManager.cpp.

                                                          {
    SkASSERT(src);
    SkASSERT(dst);
    SkASSERT(srcOffset + size <= src->size());
    SkASSERT(dstOffset + size <= dst->size());
    SkASSERT(src->intendedType() == GrGpuBufferType::kXferCpuToGpu);
    SkASSERT(dst->intendedType() != GrGpuBufferType::kXferCpuToGpu);
 
    SkDEBUGCODE(this->validate());
    SkASSERT(fContext);
 
    this->closeActiveOpsTask();
 
    sk_sp<GrRenderTask> task = GrBufferTransferRenderTask::Make(std::move(src),
                                                                srcOffset,
                                                                std::move(dst),
                                                                dstOffset,
                                                                size);
    SkASSERT(task);
 
    this->appendTask(task);
    task->makeClosed(fContext);
 
    // We have closed the previous active oplist but since a new oplist isn't being added there
    // shouldn't be an active one.
    SkASSERT(!fActiveOpsTask);
    SkDEBUGCODE(this->validate());
}

newBufferUpdateTask()

void GrDrawingManager::newBufferUpdateTask	(	sk_sp< SkData >	src,
		sk_sp< GrGpuBuffer >	dst,
		size_t	dstOffset
	)

Definition at line 880 of file GrDrawingManager.cpp.

                                                             {
    SkASSERT(src);
    SkASSERT(dst);
    SkASSERT(dstOffset + src->size() <= dst->size());
    SkASSERT(dst->intendedType() != GrGpuBufferType::kXferCpuToGpu);
    SkASSERT(!dst->isMapped());
 
    SkDEBUGCODE(this->validate());
    SkASSERT(fContext);
 
    this->closeActiveOpsTask();
 
    sk_sp<GrRenderTask> task = GrBufferUpdateRenderTask::Make(std::move(src),
                                                              std::move(dst),
                                                              dstOffset);
    SkASSERT(task);
 
    this->appendTask(task);
    task->makeClosed(fContext);
 
    // We have closed the previous active oplist but since a new oplist isn't being added there
    // shouldn't be an active one.
    SkASSERT(!fActiveOpsTask);
    SkDEBUGCODE(this->validate());
}

newCopyRenderTask()

sk_sp< GrRenderTask > GrDrawingManager::newCopyRenderTask	(	sk_sp< GrSurfaceProxy >	dst,
		SkIRect	dstRect,
		const sk_sp< GrSurfaceProxy > &	src,
		SkIRect	srcRect,
		GrSamplerState::Filter	filter,
		GrSurfaceOrigin	origin
	)

Definition at line 908 of file GrDrawingManager.cpp.

                                                                                {
    SkDEBUGCODE(this->validate());
    SkASSERT(fContext);
 
    // It'd be nicer to check this in GrCopyRenderTask::Make. This gets complicated because of
    // "active ops task" tracking. dst will be the target of our copy task but it might also be the
    // target of the active ops task. We currently require the active ops task to be closed before
    // making a new task that targets the same proxy. However, if we first close the active ops
    // task, then fail to make a copy task, the next active ops task may target the same proxy. This
    // will trip an assert related to unnecessary ops task splitting.
    if (src->framebufferOnly()) {
        return nullptr;
    }
 
    this->closeActiveOpsTask();
 
    sk_sp<GrRenderTask> task = GrCopyRenderTask::Make(this,
                                                      std::move(dst),
                                                      dstRect,
                                                      src,
                                                      srcRect,
                                                      filter,
                                                      origin);
    if (!task) {
        return nullptr;
    }
 
    this->appendTask(task);
 
    const GrCaps& caps = *fContext->priv().caps();
    // We always say skgpu::Mipmapped::kNo here since we are always just copying from the base layer
    // to another base layer. We don't need to make sure the whole mip map chain is valid.
    task->addDependency(
            this, src.get(), skgpu::Mipmapped::kNo, GrTextureResolveManager(this), caps);
    task->makeClosed(fContext);
 
    // We have closed the previous active oplist but since a new oplist isn't being added there
    // shouldn't be an active one.
    SkASSERT(!fActiveOpsTask);
    SkDEBUGCODE(this->validate());
    return task;
}

newOpsTask()

sk_sp< skgpu::ganesh::OpsTask > GrDrawingManager::newOpsTask	(	GrSurfaceProxyView	surfaceView,
		sk_sp< GrArenas >	arenas
	)

Definition at line 681 of file GrDrawingManager.cpp.

                                                                                   {
    SkDEBUGCODE(this->validate());
    SkASSERT(fContext);
 
    this->closeActiveOpsTask();
 
    sk_sp<skgpu::ganesh::OpsTask> opsTask(new skgpu::ganesh::OpsTask(
            this, std::move(surfaceView), fContext->priv().auditTrail(), std::move(arenas)));
 
    SkASSERT(this->getLastRenderTask(opsTask->target(0)) == opsTask.get());
 
    this->appendTask(opsTask);
 
    fActiveOpsTask = opsTask.get();
 
    SkDEBUGCODE(this->validate());
    return opsTask;
}

newTextureResolveRenderTask()

void GrDrawingManager::newTextureResolveRenderTask	(	sk_sp< GrSurfaceProxy >	proxy,
		GrSurfaceProxy::ResolveFlags	flags,
		const GrCaps &	caps
	)

Definition at line 742 of file GrDrawingManager.cpp.

                                                                       {
    SkDEBUGCODE(this->validate());
    SkASSERT(fContext);
 
    if (!proxy->requiresManualMSAAResolve()) {
        SkDEBUGCODE(this->validate());
        return;
    }
 
    GrRenderTask* lastTask = this->getLastRenderTask(proxy.get());
    if (!proxy->asRenderTargetProxy()->isMSAADirty() && (!lastTask || lastTask->isClosed())) {
        SkDEBUGCODE(this->validate());
        return;
    }
 
    this->closeActiveOpsTask();
 
    auto resolveTask = sk_make_sp<GrTextureResolveRenderTask>();
    // Add proxy also adds all the needed dependencies we need
    resolveTask->addProxy(this, std::move(proxy), flags, caps);
 
    auto task = this->appendTask(std::move(resolveTask));
    task->makeClosed(fContext);
 
    // We have closed the previous active oplist but since a new oplist isn't being added there
    // shouldn't be an active one.
    SkASSERT(!fActiveOpsTask);
    SkDEBUGCODE(this->validate());
}

newTextureResolveRenderTaskBefore()

GrTextureResolveRenderTask * GrDrawingManager::newTextureResolveRenderTaskBefore

(

const GrCaps &

caps

)

Definition at line 727 of file GrDrawingManager.cpp.

                            {
    // Unlike in the "new opsTask" case, we do not want to close the active opsTask, nor (if we are
    // in sorting and opsTask reduction mode) the render tasks that depend on any proxy's current
    // state. This is because those opsTasks can still receive new ops and because if they refer to
    // the mipmapped version of 'proxy', they will then come to depend on the render task being
    // created here.
    //
    // Add the new textureResolveTask before the fActiveOpsTask (if not in
    // sorting/opsTask-splitting-reduction mode) because it will depend upon this resolve task.
    // NOTE: Putting it here will also reduce the amount of work required by the topological sort.
    GrRenderTask* task = this->insertTaskBeforeLast(sk_make_sp<GrTextureResolveRenderTask>());
    return static_cast<GrTextureResolveRenderTask*>(task);
}

newTransferFromRenderTask()

void GrDrawingManager::newTransferFromRenderTask	(	const sk_sp< GrSurfaceProxy > &	srcProxy,
		const SkIRect &	srcRect,
		GrColorType	surfaceColorType,
		GrColorType	dstColorType,
		sk_sp< GrGpuBuffer >	dstBuffer,
		size_t	dstOffset
	)

Definition at line 819 of file GrDrawingManager.cpp.

                                                                   {
    SkDEBUGCODE(this->validate());
    SkASSERT(fContext);
    this->closeActiveOpsTask();
 
    GrRenderTask* task = this->appendTask(sk_make_sp<GrTransferFromRenderTask>(
            srcProxy, srcRect, surfaceColorType, dstColorType,
            std::move(dstBuffer), dstOffset));
 
    const GrCaps& caps = *fContext->priv().caps();
 
    // We always say skgpu::Mipmapped::kNo here since we are always just copying from the base
    // layer. We don't need to make sure the whole mip map chain is valid.
    task->addDependency(
            this, srcProxy.get(), skgpu::Mipmapped::kNo, GrTextureResolveManager(this), caps);
    task->makeClosed(fContext);
 
    // We have closed the previous active oplist but since a new oplist isn't being added there
    // shouldn't be an active one.
    SkASSERT(!fActiveOpsTask);
    SkDEBUGCODE(this->validate());
}

newWaitRenderTask()

void GrDrawingManager::newWaitRenderTask	(	const sk_sp< GrSurfaceProxy > &	proxy,
		std::unique_ptr< std::unique_ptr< GrSemaphore >[]>	semaphores,
		int	numSemaphores
	)

Definition at line 774 of file GrDrawingManager.cpp.

                                                            {
    SkDEBUGCODE(this->validate());
    SkASSERT(fContext);
 
    sk_sp<GrWaitRenderTask> waitTask = sk_make_sp<GrWaitRenderTask>(GrSurfaceProxyView(proxy),
                                                                    std::move(semaphores),
                                                                    numSemaphores);
 
    if (fActiveOpsTask && (fActiveOpsTask->target(0) == proxy.get())) {
        SkASSERT(this->getLastRenderTask(proxy.get()) == fActiveOpsTask);
        this->insertTaskBeforeLast(waitTask);
        // In this case we keep the current renderTask open but just insert the new waitTask
        // before it in the list. The waitTask will never need to trigger any resolves or mip
        // map generation which is the main advantage of going through the proxy version.
        // Additionally we would've had to temporarily set the wait task as the lastRenderTask
        // on the proxy, add the dependency, and then reset the lastRenderTask to
        // fActiveOpsTask. Additionally we make the waitTask depend on all of fActiveOpsTask
        // dependencies so that we don't unnecessarily reorder the waitTask before them.
        // Note: Any previous Ops already in fActiveOpsTask will get blocked by the wait
        // semaphore even though they don't need to be for correctness.
 
        // Make sure we add the dependencies of fActiveOpsTask to waitTask first or else we'll
        // get a circular self dependency of waitTask on waitTask.
        waitTask->addDependenciesFromOtherTask(fActiveOpsTask);
        fActiveOpsTask->addDependency(waitTask.get());
    } else {
        // In this case we just close the previous RenderTask and start and append the waitTask
        // to the DAG. Since it is the last task now we call setLastRenderTask on the proxy. If
        // there is a lastTask on the proxy we make waitTask depend on that task. This
        // dependency isn't strictly needed but it does keep the DAG from reordering the
        // waitTask earlier and blocking more tasks.
        if (GrRenderTask* lastTask = this->getLastRenderTask(proxy.get())) {
            waitTask->addDependency(lastTask);
        }
        this->setLastRenderTask(proxy.get(), waitTask.get());
        this->closeActiveOpsTask();
        this->appendTask(waitTask);
    }
    waitTask->makeClosed(fContext);
 
    SkDEBUGCODE(this->validate());
}

newWritePixelsTask()

bool GrDrawingManager::newWritePixelsTask	(	sk_sp< GrSurfaceProxy >	dst,
		SkIRect	rect,
		GrColorType	srcColorType,
		GrColorType	dstColorType,
		const GrMipLevel	levels[],
		int	levelCount
	)

Definition at line 956 of file GrDrawingManager.cpp.

                                                          {
    SkDEBUGCODE(this->validate());
    SkASSERT(fContext);
 
    this->closeActiveOpsTask();
    const GrCaps& caps = *fContext->priv().caps();
 
    // On platforms that prefer flushes over VRAM use (i.e., ANGLE) we're better off forcing a
    // complete flush here.
    if (!caps.preferVRAMUseOverFlushes()) {
        this->flushSurfaces(SkSpan<GrSurfaceProxy*>{},
                            SkSurfaces::BackendSurfaceAccess::kNoAccess,
                            GrFlushInfo{},
                            nullptr);
    }
 
    GrRenderTask* task = this->appendTask(GrWritePixelsTask::Make(this,
                                                                  std::move(dst),
                                                                  rect,
                                                                  srcColorType,
                                                                  dstColorType,
                                                                  levels,
                                                                  levelCount));
    if (!task) {
        return false;
    }
 
    task->makeClosed(fContext);
 
    // We have closed the previous active oplist but since a new oplist isn't being added there
    // shouldn't be an active one.
    SkASSERT(!fActiveOpsTask);
    SkDEBUGCODE(this->validate());
    return true;
}

ProgramUnitTest()

bool GrDrawingManager::ProgramUnitTest ( GrDirectContext *  , int  maxStages, int  maxLevels  )

static

Definition at line 268 of file ProgramsTest.cpp.

{ return true; }

setLastRenderTask()

void GrDrawingManager::setLastRenderTask	(	const GrSurfaceProxy *	proxy,
		GrRenderTask *	task
	)

Definition at line 547 of file GrDrawingManager.cpp.

                                                                                        {
#ifdef SK_DEBUG
    if (auto prior = this->getLastRenderTask(proxy)) {
        SkASSERT(prior->isClosed() || prior == task);
    }
#endif
    uint32_t key = proxy->uniqueID().asUInt();
    if (task) {
        fLastRenderTasks.set(key, task);
    } else if (fLastRenderTasks.find(key)) {
        fLastRenderTasks.remove(key);
    }
}

Friends And Related Function Documentation

GrOnFlushResourceProvider

friend class GrOnFlushResourceProvider

friend

Definition at line 219 of file GrDrawingManager.h.

GrRecordingContext

friend class GrRecordingContext

friend

Definition at line 220 of file GrDrawingManager.h.

---

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

• third_party/skia/src/gpu/ganesh/GrDrawingManager.h
• third_party/skia/src/gpu/ganesh/GrDrawingManager.cpp
• third_party/skia/tests/ProgramsTest.cpp