skgpu::graphite::DrawContext Class Reference

#include <DrawContext.h>

Inheritance diagram for skgpu::graphite::DrawContext:

Public Member Functions
	~DrawContext () override
const SkImageInfo &	imageInfo () const
const SkColorInfo &	colorInfo () const
TextureProxy *	target ()
const TextureProxy *	target () const
sk_sp< TextureProxy >	refTarget () const
const TextureProxyView &	readSurfaceView () const
const SkSurfaceProps &	surfaceProps () const
int	pendingRenderSteps () const
void	clear (const SkColor4f &clearColor)
void	discard ()
void	recordDraw (const Renderer *renderer, const Transform &localToDevice, const Geometry &geometry, const Clip &clip, DrawOrder ordering, const PaintParams *paint, const StrokeStyle *stroke)
bool	recordUpload (Recorder *recorder, sk_sp< TextureProxy > targetProxy, const SkColorInfo &srcColorInfo, const SkColorInfo &dstColorInfo, const std::vector< MipLevel > &levels, const SkIRect &dstRect, std::unique_ptr< ConditionalUploadContext >)
PathAtlas *	getComputePathAtlas (Recorder *)
void	flush (Recorder *)
sk_sp< Task >	snapDrawTask (Recorder *)
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< DrawContext >	Make (const Caps *caps, sk_sp< TextureProxy > target, SkISize deviceSize, const SkColorInfo &, const SkSurfaceProps &)

Detailed Description

DrawContext records draw commands into a specific Surface, via a general task graph representing GPU work and their inter-dependencies.

Definition at line 44 of file DrawContext.h.

Constructor & Destructor Documentation

~DrawContext()

skgpu::graphite::DrawContext::~DrawContext ( )

overridedefault

Member Function Documentation

clear()

void skgpu::graphite::DrawContext::clear

(

const SkColor4f &

clearColor

)

Definition at line 112 of file DrawContext.cpp.

                                                   {
    this->discard();
 
    fPendingLoadOp = LoadOp::kClear;
    SkPMColor4f pmColor = clearColor.premul();
    fPendingClearColor = pmColor.array();
}

colorInfo()

const SkColorInfo & skgpu::graphite::DrawContext::colorInfo ( ) const

inline

Definition at line 55 of file DrawContext.h.

{ return fImageInfo.colorInfo(); }

discard()

void skgpu::graphite::DrawContext::discard

(

)

Definition at line 120 of file DrawContext.cpp.

                          {
    // Non-loading operations on a fully lazy target can corrupt data beyond the DrawContext's
    // region so should be avoided.
    SkASSERT(!fTarget->isFullyLazy());
 
    // A fullscreen clear or discard will overwrite anything that came before, so clear the DrawList
    // NOTE: Eventually the current DrawTask should be reset, once there are no longer implicit
    // dependencies on atlas tasks between DrawContexts. When that's resolved, the only tasks in the
    // current DrawTask are those that directly impact the target, which becomes irrelevant with the
    // clear op overwriting it. For now, preserve the previous tasks that might include atlas
    // uploads that are not explicitly shared between DrawContexts.
    if (fPendingDraws->renderStepCount() > 0) {
        fPendingDraws = std::make_unique<DrawList>();
    }
    if (fComputePathAtlas) {
        fComputePathAtlas->reset();
    }
 
    if (discard_op_should_use_clear(fImageInfo.colorType())) {
        // In theory the clear color shouldn't matter since a discardable state should be fully
        // overwritten by later draws, but if a previous call to clear() had injected bad data,
        // the discard should not inherit it.
        fPendingClearColor = {0.f, 0.f, 0.f, 0.f};
        fPendingLoadOp = LoadOp::kClear;
    } else {
        fPendingLoadOp = LoadOp::kDiscard;
    }
}

flush()

void skgpu::graphite::DrawContext::flush

(

Recorder *

recorder

)

Definition at line 186 of file DrawContext.cpp.

                                          {
    if (fPendingUploads->size() > 0) {
        TRACE_EVENT_INSTANT1("skia.gpu", TRACE_FUNC, TRACE_EVENT_SCOPE_THREAD,
                             "# uploads", fPendingUploads->size());
        fCurrentDrawTask->addTask(UploadTask::Make(fPendingUploads.get()));
        // The UploadTask steals the collected upload instances, automatically resetting this list
        SkASSERT(fPendingUploads->size() == 0);
    }
 
    // Generate compute dispatches that render into the atlas texture used by pending draws.
    // TODO: Once compute atlas caching is implemented, DrawContext might not hold onto to this
    // at which point a recordDispatch() could be added and it stores a pending dispatches list that
    // much like how uploads are handled. In that case, Device would be responsible for triggering
    // the recording of dispatches, but that may happen naturally in AtlasProvider::recordUploads().
    if (fComputePathAtlas) {
        auto dispatchGroup = fComputePathAtlas->recordDispatches(recorder);
        fComputePathAtlas->reset();
 
        if (dispatchGroup) {
            // For now this check is valid as all coverage mask draws involve dispatches
            SkASSERT(fPendingDraws->hasCoverageMaskDraws());
 
            TRACE_EVENT_INSTANT1("skia.gpu", TRACE_FUNC, TRACE_EVENT_SCOPE_THREAD,
                                 "# dispatches", dispatchGroup->dispatches().size());
            ComputeTask::DispatchGroupList dispatches;
            dispatches.emplace_back(std::move(dispatchGroup));
            fCurrentDrawTask->addTask(ComputeTask::Make(std::move(dispatches)));
        } // else no pending compute work needed to be recorded
    } // else platform doesn't support compute or atlas was never initialized.
 
    if (fPendingDraws->renderStepCount() == 0 && fPendingLoadOp != LoadOp::kClear) {
        // Nothing will be rasterized to the target that warrants a RenderPassTask, but we preserve
        // any added uploads or compute tasks since those could also affect the target w/o
        // rasterizing anything directly.
        return;
    }
 
    // Convert the pending draws and load/store ops into a DrawPass that will be executed after
    // the collected uploads and compute dispatches.
    // TODO: At this point, there's only ever one DrawPass in a RenderPassTask to a target. When
    // subpasses are implemented, they will either be collected alongside fPendingDraws or added
    // to the RenderPassTask separately.
    std::unique_ptr<DrawPass> pass = DrawPass::Make(recorder,
                                                    std::move(fPendingDraws),
                                                    fTarget,
                                                    this->imageInfo(),
                                                    std::make_pair(fPendingLoadOp, fPendingStoreOp),
                                                    fPendingClearColor);
    fPendingDraws = std::make_unique<DrawList>();
    // Now that there is content drawn to the target, that content must be loaded on any subsequent
    // render pass.
    fPendingLoadOp = LoadOp::kLoad;
    fPendingStoreOp = StoreOp::kStore;
 
    if (pass) {
        SkASSERT(fTarget.get() == pass->target());
 
        const Caps* caps = recorder->priv().caps();
        auto [loadOp, storeOp] = pass->ops();
        auto writeSwizzle = caps->getWriteSwizzle(this->colorInfo().colorType(),
                                                  fTarget->textureInfo());
 
        RenderPassDesc desc = RenderPassDesc::Make(caps, fTarget->textureInfo(), loadOp, storeOp,
                                                   pass->depthStencilFlags(),
                                                   pass->clearColor(),
                                                   pass->requiresMSAA(),
                                                   writeSwizzle);
 
        RenderPassTask::DrawPassList passes;
        passes.emplace_back(std::move(pass));
        fCurrentDrawTask->addTask(RenderPassTask::Make(std::move(passes), desc, fTarget));
    }
    // else pass creation failed, DrawPass will have logged why. Don't discard the previously
    // accumulated tasks, however, since they may represent operations on an atlas that other
    // DrawContexts now implicitly depend on.
}

getComputePathAtlas()

PathAtlas * skgpu::graphite::DrawContext::getComputePathAtlas

(

Recorder *

recorder

)

Definition at line 179 of file DrawContext.cpp.

                                                              {
    if (!fComputePathAtlas) {
        fComputePathAtlas = recorder->priv().atlasProvider()->createComputePathAtlas(recorder);
    }
    return fComputePathAtlas.get();
}

imageInfo()

const SkImageInfo & skgpu::graphite::DrawContext::imageInfo ( ) const

inline

Definition at line 54 of file DrawContext.h.

{ return fImageInfo;    }

Make()

sk_sp< DrawContext > skgpu::graphite::DrawContext::Make ( const Caps *  caps, sk_sp< TextureProxy >  target, SkISize  deviceSize, const SkColorInfo &  colorInfo, const SkSurfaceProps &  props  )

static

Definition at line 64 of file DrawContext.cpp.

                                                                  {
    if (!target) {
        return nullptr;
    }
    // We don't render to unknown or unpremul alphatypes
    if (colorInfo.alphaType() == kUnknown_SkAlphaType ||
        colorInfo.alphaType() == kUnpremul_SkAlphaType) {
        return nullptr;
    }
    if (!caps->isRenderable(target->textureInfo())) {
        return nullptr;
    }
 
    // Accept an approximate-fit texture, but make sure it's at least as large as the device's
    // logical size.
    // TODO: validate that the color type and alpha type are compatible with the target's info
    SkASSERT(target->isFullyLazy() || (target->dimensions().width() >= deviceSize.width() &&
                                       target->dimensions().height() >= deviceSize.height()));
    SkImageInfo imageInfo = SkImageInfo::Make(deviceSize, colorInfo);
    return sk_sp<DrawContext>(new DrawContext(caps, std::move(target), imageInfo, props));
}

pendingRenderSteps()

int skgpu::graphite::DrawContext::pendingRenderSteps ( ) const

inline

Definition at line 65 of file DrawContext.h.

{ return fPendingDraws->renderStepCount(); }

readSurfaceView()

const TextureProxyView & skgpu::graphite::DrawContext::readSurfaceView ( ) const

inline

Definition at line 61 of file DrawContext.h.

{ return fReadView; }

recordDraw()

void skgpu::graphite::DrawContext::recordDraw	(	const Renderer *	renderer,
		const Transform &	localToDevice,
		const Geometry &	geometry,
		const Clip &	clip,
		DrawOrder	ordering,
		const PaintParams *	paint,
		const StrokeStyle *	stroke
	)

Definition at line 149 of file DrawContext.cpp.

                                                        {
    SkASSERT(SkIRect::MakeSize(this->imageInfo().dimensions()).contains(clip.scissor()));
    fPendingDraws->recordDraw(renderer, localToDevice, geometry, clip, ordering, paint, stroke);
}

recordUpload()

bool skgpu::graphite::DrawContext::recordUpload	(	Recorder *	recorder,
		sk_sp< TextureProxy >	targetProxy,
		const SkColorInfo &	srcColorInfo,
		const SkColorInfo &	dstColorInfo,
		const std::vector< MipLevel > &	levels,
		const SkIRect &	dstRect,
		std::unique_ptr< ConditionalUploadContext >	condContext
	)

Definition at line 160 of file DrawContext.cpp.

                                                                                    {
    // Our caller should have clipped to the bounds of the surface already.
    SkASSERT(targetProxy->isFullyLazy() ||
             SkIRect::MakeSize(targetProxy->dimensions()).contains(dstRect));
    return fPendingUploads->recordUpload(recorder,
                                         std::move(targetProxy),
                                         srcColorInfo,
                                         dstColorInfo,
                                         levels,
                                         dstRect,
                                         std::move(condContext));
}

refTarget()

sk_sp< TextureProxy > skgpu::graphite::DrawContext::refTarget ( ) const

inline

Definition at line 58 of file DrawContext.h.

{ return fTarget; }

snapDrawTask()

sk_sp< Task > skgpu::graphite::DrawContext::snapDrawTask

(

Recorder *

recorder

)

Definition at line 263 of file DrawContext.cpp.

                                                        {
    // If flush() was explicitly called earlier and no new work was recorded, this call to flush()
    // is a no-op and shouldn't hurt performance.
    this->flush(recorder);
 
    if (!fCurrentDrawTask->hasTasks()) {
        return nullptr;
    }
 
    sk_sp<Task> snappedTask = std::move(fCurrentDrawTask);
    fCurrentDrawTask = sk_make_sp<DrawTask>(fTarget);
    return snappedTask;
}

surfaceProps()

const SkSurfaceProps & skgpu::graphite::DrawContext::surfaceProps ( ) const

inline

Definition at line 63 of file DrawContext.h.

{ return fSurfaceProps; }

target() [1/2]

TextureProxy * skgpu::graphite::DrawContext::target ( )

inline

Definition at line 56 of file DrawContext.h.

{ return fTarget.get(); }

target() [2/2]

const TextureProxy * skgpu::graphite::DrawContext::target ( ) const

inline

Definition at line 57 of file DrawContext.h.

{ return fTarget.get(); }

---

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

• third_party/skia/src/gpu/graphite/DrawContext.h
• third_party/skia/src/gpu/graphite/DrawContext.cpp