GrRenderTargetContext->GrSurfaceDrawContext
Just the class/files. variable names and additional comments to follow.
Change-Id: Ic03d07fd5009eaf3d706c2536486a117328963fc
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/342617
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
diff --git a/src/gpu/GrSurfaceDrawContext.cpp b/src/gpu/GrSurfaceDrawContext.cpp
new file mode 100644
index 0000000..96ba62a
--- /dev/null
+++ b/src/gpu/GrSurfaceDrawContext.cpp
@@ -0,0 +1,2155 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "src/gpu/GrSurfaceDrawContext.h"
+
+#include "include/core/SkDrawable.h"
+#include "include/core/SkVertices.h"
+#include "include/gpu/GrBackendSemaphore.h"
+#include "include/gpu/GrDirectContext.h"
+#include "include/gpu/GrRecordingContext.h"
+#include "include/private/GrImageContext.h"
+#include "include/private/SkShadowFlags.h"
+#include "include/utils/SkShadowUtils.h"
+#include "src/core/SkAutoPixmapStorage.h"
+#include "src/core/SkConvertPixels.h"
+#include "src/core/SkDrawShadowInfo.h"
+#include "src/core/SkGlyphRunPainter.h"
+#include "src/core/SkLatticeIter.h"
+#include "src/core/SkMatrixPriv.h"
+#include "src/core/SkMatrixProvider.h"
+#include "src/core/SkRRectPriv.h"
+#include "src/core/SkSurfacePriv.h"
+#include "src/gpu/GrAppliedClip.h"
+#include "src/gpu/GrAttachment.h"
+#include "src/gpu/GrAuditTrail.h"
+#include "src/gpu/GrBlurUtils.h"
+#include "src/gpu/GrCaps.h"
+#include "src/gpu/GrClip.h"
+#include "src/gpu/GrColor.h"
+#include "src/gpu/GrDataUtils.h"
+#include "src/gpu/GrDirectContextPriv.h"
+#include "src/gpu/GrDrawingManager.h"
+#include "src/gpu/GrGpuResourcePriv.h"
+#include "src/gpu/GrImageContextPriv.h"
+#include "src/gpu/GrImageInfo.h"
+#include "src/gpu/GrMemoryPool.h"
+#include "src/gpu/GrPathRenderer.h"
+#include "src/gpu/GrProxyProvider.h"
+#include "src/gpu/GrRenderTarget.h"
+#include "src/gpu/GrResourceProvider.h"
+#include "src/gpu/GrStyle.h"
+#include "src/gpu/GrTracing.h"
+#include "src/gpu/SkGr.h"
+#include "src/gpu/effects/GrBicubicEffect.h"
+#include "src/gpu/effects/GrRRectEffect.h"
+#include "src/gpu/geometry/GrQuad.h"
+#include "src/gpu/geometry/GrQuadUtils.h"
+#include "src/gpu/geometry/GrStyledShape.h"
+#include "src/gpu/ops/GrAtlasTextOp.h"
+#include "src/gpu/ops/GrClearOp.h"
+#include "src/gpu/ops/GrDrawAtlasOp.h"
+#include "src/gpu/ops/GrDrawOp.h"
+#include "src/gpu/ops/GrDrawVerticesOp.h"
+#include "src/gpu/ops/GrDrawableOp.h"
+#include "src/gpu/ops/GrFillRRectOp.h"
+#include "src/gpu/ops/GrFillRectOp.h"
+#include "src/gpu/ops/GrLatticeOp.h"
+#include "src/gpu/ops/GrOp.h"
+#include "src/gpu/ops/GrOvalOpFactory.h"
+#include "src/gpu/ops/GrRegionOp.h"
+#include "src/gpu/ops/GrShadowRRectOp.h"
+#include "src/gpu/ops/GrStencilPathOp.h"
+#include "src/gpu/ops/GrStrokeRectOp.h"
+#include "src/gpu/ops/GrTextureOp.h"
+#include "src/gpu/text/GrSDFTOptions.h"
+#include "src/gpu/text/GrTextBlobCache.h"
+
+#define ASSERT_OWNED_RESOURCE(R) SkASSERT(!(R) || (R)->getContext() == this->drawingManager()->getContext())
+#define ASSERT_SINGLE_OWNER GR_ASSERT_SINGLE_OWNER(this->singleOwner())
+#define RETURN_IF_ABANDONED if (fContext->abandoned()) { return; }
+#define RETURN_FALSE_IF_ABANDONED if (fContext->abandoned()) { return false; }
+#define RETURN_NULL_IF_ABANDONED if (fContext->abandoned()) { return nullptr; }
+
+//////////////////////////////////////////////////////////////////////////////
+
+class AutoCheckFlush {
+public:
+ AutoCheckFlush(GrDrawingManager* drawingManager) : fDrawingManager(drawingManager) {
+ SkASSERT(fDrawingManager);
+ }
+ ~AutoCheckFlush() { fDrawingManager->flushIfNecessary(); }
+
+private:
+ GrDrawingManager* fDrawingManager;
+};
+
+std::unique_ptr<GrSurfaceDrawContext> GrSurfaceDrawContext::Make(GrRecordingContext* context,
+ GrColorType colorType,
+ sk_sp<SkColorSpace> colorSpace,
+ sk_sp<GrSurfaceProxy> proxy,
+ GrSurfaceOrigin origin,
+ const SkSurfaceProps* surfaceProps,
+ bool flushTimeOpsTask) {
+ if (!proxy) {
+ return nullptr;
+ }
+
+ const GrBackendFormat& format = proxy->backendFormat();
+ GrSwizzle readSwizzle, writeSwizzle;
+ if (colorType != GrColorType::kUnknown) {
+ readSwizzle = context->priv().caps()->getReadSwizzle(format, colorType);
+ writeSwizzle = context->priv().caps()->getWriteSwizzle(format, colorType);
+ }
+
+ GrSurfaceProxyView readView ( proxy, origin, readSwizzle);
+ GrSurfaceProxyView writeView(std::move(proxy), origin, writeSwizzle);
+
+ return std::make_unique<GrSurfaceDrawContext>(context,
+ std::move(readView),
+ std::move(writeView),
+ colorType,
+ std::move(colorSpace),
+ surfaceProps,
+ flushTimeOpsTask);
+}
+
+std::unique_ptr<GrSurfaceDrawContext> GrSurfaceDrawContext::Make(
+ GrRecordingContext* context,
+ sk_sp<SkColorSpace> colorSpace,
+ SkBackingFit fit,
+ SkISize dimensions,
+ const GrBackendFormat& format,
+ int sampleCnt,
+ GrMipmapped mipMapped,
+ GrProtected isProtected,
+ GrSwizzle readSwizzle,
+ GrSwizzle writeSwizzle,
+ GrSurfaceOrigin origin,
+ SkBudgeted budgeted,
+ const SkSurfaceProps* surfaceProps) {
+ // It is probably not necessary to check if the context is abandoned here since uses of the
+ // GrSurfaceDrawContext which need the context will mostly likely fail later on without an
+ // issue. However having this hear adds some reassurance in case there is a path doesn't handle
+ // an abandoned context correctly. It also lets us early out of some extra work.
+ if (context->abandoned()) {
+ return nullptr;
+ }
+
+ sk_sp<GrTextureProxy> proxy = context->priv().proxyProvider()->createProxy(
+ format,
+ dimensions,
+ GrRenderable::kYes,
+ sampleCnt,
+ mipMapped,
+ fit,
+ budgeted,
+ isProtected);
+ if (!proxy) {
+ return nullptr;
+ }
+
+ GrSurfaceProxyView readView ( proxy, origin, readSwizzle);
+ GrSurfaceProxyView writeView(std::move(proxy), origin, writeSwizzle);
+
+ auto rtc = std::make_unique<GrSurfaceDrawContext>(context,
+ std::move(readView),
+ std::move(writeView),
+ GrColorType::kUnknown,
+ std::move(colorSpace),
+ surfaceProps);
+ rtc->discard();
+ return rtc;
+}
+
+std::unique_ptr<GrSurfaceDrawContext> GrSurfaceDrawContext::Make(
+ GrRecordingContext* context,
+ GrColorType colorType,
+ sk_sp<SkColorSpace> colorSpace,
+ SkBackingFit fit,
+ SkISize dimensions,
+ int sampleCnt,
+ GrMipmapped mipMapped,
+ GrProtected isProtected,
+ GrSurfaceOrigin origin,
+ SkBudgeted budgeted,
+ const SkSurfaceProps* surfaceProps) {
+ auto format = context->priv().caps()->getDefaultBackendFormat(colorType, GrRenderable::kYes);
+ if (!format.isValid()) {
+ return nullptr;
+ }
+ sk_sp<GrTextureProxy> proxy = context->priv().proxyProvider()->createProxy(format,
+ dimensions,
+ GrRenderable::kYes,
+ sampleCnt,
+ mipMapped,
+ fit,
+ budgeted,
+ isProtected);
+ if (!proxy) {
+ return nullptr;
+ }
+
+ return GrSurfaceDrawContext::Make(context,
+ colorType,
+ std::move(colorSpace),
+ std::move(proxy),
+ origin,
+ surfaceProps);
+}
+
+static inline GrColorType color_type_fallback(GrColorType ct) {
+ switch (ct) {
+ // kRGBA_8888 is our default fallback for many color types that may not have renderable
+ // backend formats.
+ case GrColorType::kAlpha_8:
+ case GrColorType::kBGR_565:
+ case GrColorType::kABGR_4444:
+ case GrColorType::kBGRA_8888:
+ case GrColorType::kRGBA_1010102:
+ case GrColorType::kBGRA_1010102:
+ case GrColorType::kRGBA_F16:
+ case GrColorType::kRGBA_F16_Clamped:
+ return GrColorType::kRGBA_8888;
+ case GrColorType::kAlpha_F16:
+ return GrColorType::kRGBA_F16;
+ case GrColorType::kGray_8:
+ return GrColorType::kRGB_888x;
+ default:
+ return GrColorType::kUnknown;
+ }
+}
+
+std::tuple<GrColorType, GrBackendFormat> GrSurfaceDrawContext::GetFallbackColorTypeAndFormat(
+ GrImageContext* context, GrColorType colorType, int sampleCnt) {
+ auto caps = context->priv().caps();
+ do {
+ auto format = caps->getDefaultBackendFormat(colorType, GrRenderable::kYes);
+ // We continue to the fallback color type if there no default renderable format or we
+ // requested msaa and the format doesn't support msaa.
+ if (format.isValid() && caps->isFormatRenderable(format, sampleCnt)) {
+ return {colorType, format};
+ }
+ colorType = color_type_fallback(colorType);
+ } while (colorType != GrColorType::kUnknown);
+ return {GrColorType::kUnknown, {}};
+}
+
+std::unique_ptr<GrSurfaceDrawContext> GrSurfaceDrawContext::MakeWithFallback(
+ GrRecordingContext* context,
+ GrColorType colorType,
+ sk_sp<SkColorSpace> colorSpace,
+ SkBackingFit fit,
+ SkISize dimensions,
+ int sampleCnt,
+ GrMipmapped mipMapped,
+ GrProtected isProtected,
+ GrSurfaceOrigin origin,
+ SkBudgeted budgeted,
+ const SkSurfaceProps* surfaceProps) {
+ auto [ct, format] = GetFallbackColorTypeAndFormat(context, colorType, sampleCnt);
+ if (ct == GrColorType::kUnknown) {
+ return nullptr;
+ }
+ return GrSurfaceDrawContext::Make(context, ct, colorSpace, fit, dimensions, sampleCnt,
+ mipMapped, isProtected, origin, budgeted, surfaceProps);
+}
+
+std::unique_ptr<GrSurfaceDrawContext> GrSurfaceDrawContext::MakeFromBackendTexture(
+ GrRecordingContext* context,
+ GrColorType colorType,
+ sk_sp<SkColorSpace> colorSpace,
+ const GrBackendTexture& tex,
+ int sampleCnt,
+ GrSurfaceOrigin origin,
+ const SkSurfaceProps* surfaceProps,
+ sk_sp<GrRefCntedCallback> releaseHelper) {
+ SkASSERT(sampleCnt > 0);
+ sk_sp<GrTextureProxy> proxy(context->priv().proxyProvider()->wrapRenderableBackendTexture(
+ tex, sampleCnt, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
+ std::move(releaseHelper)));
+ if (!proxy) {
+ return nullptr;
+ }
+
+ return GrSurfaceDrawContext::Make(context, colorType, std::move(colorSpace), std::move(proxy),
+ origin, surfaceProps);
+}
+
+std::unique_ptr<GrSurfaceDrawContext> GrSurfaceDrawContext::MakeFromBackendRenderTarget(
+ GrRecordingContext* context,
+ GrColorType colorType,
+ sk_sp<SkColorSpace> colorSpace,
+ const GrBackendRenderTarget& rt,
+ GrSurfaceOrigin origin,
+ const SkSurfaceProps* surfaceProps,
+ sk_sp<GrRefCntedCallback> releaseHelper) {
+ sk_sp<GrSurfaceProxy> proxy(
+ context->priv().proxyProvider()->wrapBackendRenderTarget(rt, std::move(releaseHelper)));
+ if (!proxy) {
+ return nullptr;
+ }
+
+ return GrSurfaceDrawContext::Make(context, colorType, std::move(colorSpace), std::move(proxy),
+ origin, surfaceProps);
+}
+
+std::unique_ptr<GrSurfaceDrawContext> GrSurfaceDrawContext::MakeFromVulkanSecondaryCB(
+ GrRecordingContext* context,
+ const SkImageInfo& imageInfo,
+ const GrVkDrawableInfo& vkInfo,
+ const SkSurfaceProps* props) {
+ sk_sp<GrSurfaceProxy> proxy(
+ context->priv().proxyProvider()->wrapVulkanSecondaryCBAsRenderTarget(imageInfo,
+ vkInfo));
+ if (!proxy) {
+ return nullptr;
+ }
+
+ return GrSurfaceDrawContext::Make(context, SkColorTypeToGrColorType(imageInfo.colorType()),
+ imageInfo.refColorSpace(), std::move(proxy),
+ kTopLeft_GrSurfaceOrigin, props);
+}
+
+// In MDB mode the reffing of the 'getLastOpsTask' call's result allows in-progress
+// GrOpsTask to be picked up and added to by renderTargetContexts lower in the call
+// stack. When this occurs with a closed GrOpsTask, a new one will be allocated
+// when the renderTargetContext attempts to use it (via getOpsTask).
+GrSurfaceDrawContext::GrSurfaceDrawContext(GrRecordingContext* context,
+ GrSurfaceProxyView readView,
+ GrSurfaceProxyView writeView,
+ GrColorType colorType,
+ sk_sp<SkColorSpace> colorSpace,
+ const SkSurfaceProps* surfaceProps,
+ bool flushTimeOpsTask)
+ : GrSurfaceContext(context,
+ std::move(readView),
+ {colorType, kPremul_SkAlphaType, std::move(colorSpace)})
+ , fWriteView(std::move(writeView))
+ , fSurfaceProps(SkSurfacePropsCopyOrDefault(surfaceProps))
+ , fFlushTimeOpsTask(flushTimeOpsTask)
+ , fGlyphPainter(*this) {
+ fOpsTask = sk_ref_sp(context->priv().drawingManager()->getLastOpsTask(this->asSurfaceProxy()));
+ SkASSERT(this->asSurfaceProxy() == fWriteView.proxy());
+ SkASSERT(this->origin() == fWriteView.origin());
+
+ SkDEBUGCODE(this->validate();)
+}
+
+#ifdef SK_DEBUG
+void GrSurfaceDrawContext::onValidate() const {
+ if (fOpsTask && !fOpsTask->isClosed()) {
+ SkASSERT(this->drawingManager()->getLastRenderTask(fWriteView.proxy()) == fOpsTask.get());
+ }
+}
+#endif
+
+GrSurfaceDrawContext::~GrSurfaceDrawContext() {
+ ASSERT_SINGLE_OWNER
+}
+
+inline GrAAType GrSurfaceDrawContext::chooseAAType(GrAA aa) {
+ if (GrAA::kNo == aa) {
+ // On some devices we cannot disable MSAA if it is enabled so we make the AA type reflect
+ // that.
+ if (this->numSamples() > 1 && !this->caps()->multisampleDisableSupport()) {
+ return GrAAType::kMSAA;
+ }
+ return GrAAType::kNone;
+ }
+ return (this->numSamples() > 1) ? GrAAType::kMSAA : GrAAType::kCoverage;
+}
+
+GrMipmapped GrSurfaceDrawContext::mipmapped() const {
+ if (const GrTextureProxy* proxy = this->asTextureProxy()) {
+ return proxy->mipmapped();
+ }
+ return GrMipmapped::kNo;
+}
+
+GrOpsTask* GrSurfaceDrawContext::getOpsTask() {
+ ASSERT_SINGLE_OWNER
+ SkDEBUGCODE(this->validate();)
+
+ if (!fOpsTask || fOpsTask->isClosed()) {
+ sk_sp<GrOpsTask> newOpsTask = this->drawingManager()->newOpsTask(this->writeSurfaceView(),
+ fFlushTimeOpsTask);
+ if (fOpsTask && fNumStencilSamples > 0) {
+ // Store the stencil values in memory upon completion of fOpsTask.
+ fOpsTask->setMustPreserveStencil();
+ // Reload the stencil buffer content at the beginning of newOpsTask.
+ // FIXME: Could the topo sort insert a task between these two that modifies the stencil
+ // values?
+ newOpsTask->setInitialStencilContent(GrOpsTask::StencilContent::kPreserved);
+ }
+ fOpsTask = std::move(newOpsTask);
+ }
+ SkASSERT(!fOpsTask->isClosed());
+ return fOpsTask.get();
+}
+
+static SkColor compute_canonical_color(const SkPaint& paint, bool lcd) {
+ SkColor canonicalColor = SkPaintPriv::ComputeLuminanceColor(paint);
+ if (lcd) {
+ // This is the correct computation for canonicalColor, but there are tons of cases where LCD
+ // can be modified. For now we just regenerate if any run in a textblob has LCD.
+ // TODO figure out where all of these modifications are and see if we can incorporate that
+ // logic at a higher level *OR* use sRGB
+ //canonicalColor = SkMaskGamma::CanonicalColor(canonicalColor);
+
+ // TODO we want to figure out a way to be able to use the canonical color on LCD text,
+ // see the note above. We pick a dummy value for LCD text to ensure we always match the
+ // same key
+ return SK_ColorTRANSPARENT;
+ } else {
+ // A8, though can have mixed BMP text but it shouldn't matter because BMP text won't have
+ // gamma corrected masks anyways, nor color
+ U8CPU lum = SkComputeLuminance(SkColorGetR(canonicalColor),
+ SkColorGetG(canonicalColor),
+ SkColorGetB(canonicalColor));
+ // reduce to our finite number of bits
+ canonicalColor = SkMaskGamma::CanonicalColor(SkColorSetRGB(lum, lum, lum));
+ }
+ return canonicalColor;
+}
+
+void GrSurfaceDrawContext::drawGlyphRunList(const GrClip* clip,
+ const SkMatrixProvider& viewMatrix,
+ const SkGlyphRunList& glyphRunList) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawGlyphRunList", fContext);
+
+ // Drawing text can cause us to do inline uploads. This is not supported for wrapped vulkan
+ // secondary command buffers because it would require stopping and starting a render pass which
+ // we don't have access to.
+ if (this->wrapsVkSecondaryCB()) {
+ return;
+ }
+
+ GrSDFTOptions options = fContext->priv().SDFTOptions();
+ GrTextBlobCache* textBlobCache = fContext->priv().getTextBlobCache();
+
+ // Get the first paint to use as the key paint.
+ const SkPaint& drawPaint = glyphRunList.paint();
+
+ SkMaskFilterBase::BlurRec blurRec;
+ // It might be worth caching these things, but its not clear at this time
+ // TODO for animated mask filters, this will fill up our cache. We need a safeguard here
+ const SkMaskFilter* mf = drawPaint.getMaskFilter();
+ bool canCache = glyphRunList.canCache() &&
+ !(drawPaint.getPathEffect() || (mf && !as_MFB(mf)->asABlur(&blurRec)));
+
+ // If we're doing linear blending, then we can disable the gamma hacks.
+ // Otherwise, leave them on. In either case, we still want the contrast boost:
+ // TODO: Can we be even smarter about mask gamma based on the dest transfer function?
+ SkScalerContextFlags scalerContextFlags = this->colorInfo().isLinearlyBlended()
+ ? SkScalerContextFlags::kBoostContrast
+ : SkScalerContextFlags::kFakeGammaAndBoostContrast;
+
+ sk_sp<GrTextBlob> blob;
+ GrTextBlob::Key key;
+ if (canCache) {
+ bool hasLCD = glyphRunList.anyRunsLCD();
+
+ // We canonicalize all non-lcd draws to use kUnknown_SkPixelGeometry
+ SkPixelGeometry pixelGeometry =
+ hasLCD ? fSurfaceProps.pixelGeometry() : kUnknown_SkPixelGeometry;
+
+ GrColor canonicalColor = compute_canonical_color(drawPaint, hasLCD);
+
+ key.fPixelGeometry = pixelGeometry;
+ key.fUniqueID = glyphRunList.uniqueID();
+ key.fStyle = drawPaint.getStyle();
+ if (key.fStyle != SkPaint::kFill_Style) {
+ key.fFrameWidth = drawPaint.getStrokeWidth();
+ key.fMiterLimit = drawPaint.getStrokeMiter();
+ key.fJoin = drawPaint.getStrokeJoin();
+ }
+ key.fHasBlur = SkToBool(mf);
+ if (key.fHasBlur) {
+ key.fBlurRec = blurRec;
+ }
+ key.fCanonicalColor = canonicalColor;
+ key.fScalerContextFlags = scalerContextFlags;
+ blob = textBlobCache->find(key);
+ }
+
+ SkMatrix drawMatrix(viewMatrix.localToDevice());
+ SkPoint drawOrigin = glyphRunList.origin();
+ drawMatrix.preTranslate(drawOrigin.x(), drawOrigin.y());
+ if (blob == nullptr || !blob->canReuse(drawPaint, drawMatrix)) {
+ if (blob != nullptr) {
+ // We have to remake the blob because changes may invalidate our masks.
+ // TODO we could probably get away with reuse most of the time if the pointer is unique,
+ // but we'd have to clear the SubRun information
+ textBlobCache->remove(blob.get());
+ }
+
+ blob = GrTextBlob::Make(glyphRunList, drawMatrix);
+ if (canCache) {
+ blob->addKey(key);
+ textBlobCache->add(glyphRunList, blob);
+ }
+
+ // TODO(herb): redo processGlyphRunList to handle shifted draw matrix.
+ bool supportsSDFT = fContext->priv().caps()->shaderCaps()->supportsDistanceFieldText();
+ for (auto& glyphRun : glyphRunList) {
+ fGlyphPainter.processGlyphRun(glyphRun,
+ viewMatrix.localToDevice(),
+ drawOrigin,
+ drawPaint,
+ fSurfaceProps,
+ supportsSDFT,
+ options,
+ blob.get());
+ }
+ }
+
+ for (GrSubRun* subRun : blob->subRunList()) {
+ subRun->draw(clip, viewMatrix, glyphRunList, this);
+ }
+}
+
+void GrSurfaceDrawContext::discard() {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "discard", fContext);
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ this->getOpsTask()->discard();
+}
+
+static void clear_to_grpaint(const SkPMColor4f& color, GrPaint* paint) {
+ paint->setColor4f(color);
+ if (color.isOpaque()) {
+ // Can just rely on the src-over blend mode to do the right thing
+ paint->setPorterDuffXPFactory(SkBlendMode::kSrcOver);
+ } else {
+ // A clear overwrites the prior color, so even if it's transparent, it behaves as if it
+ // were src blended
+ paint->setPorterDuffXPFactory(SkBlendMode::kSrc);
+ }
+}
+
+// NOTE: We currently pass the premul color unmodified to the gpu, since we assume the GrRTC has a
+// premul alpha type. If we ever support different alpha type render targets, this function should
+// transform the color as appropriate.
+void GrSurfaceDrawContext::internalClear(const SkIRect* scissor,
+ const SkPMColor4f& color,
+ bool upgradePartialToFull) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "clear", fContext);
+
+ // There are three ways clears are handled: load ops, native clears, and draws. Load ops are
+ // only for fullscreen clears; native clears can be fullscreen or with scissors if the backend
+ // supports then. Drawing an axis-aligned rect is the fallback path.
+ GrScissorState scissorState(this->asSurfaceProxy()->backingStoreDimensions());
+ if (scissor && !scissorState.set(*scissor)) {
+ // The clear is offscreen, so skip it (normally this would be handled by addDrawOp,
+ // except clear ops are not draw ops).
+ return;
+ }
+
+ // If we have a scissor but it's okay to clear beyond it for performance reasons, then disable
+ // the test. We only do this when the clear would be handled by a load op or natively.
+ if (scissorState.enabled() && !this->caps()->performColorClearsAsDraws()) {
+ if (upgradePartialToFull && (this->caps()->preferFullscreenClears() ||
+ this->caps()->shouldInitializeTextures())) {
+ // TODO: wrt the shouldInitializeTextures path, it would be more performant to
+ // only clear the entire target if we knew it had not been cleared before. As
+ // is this could end up doing a lot of redundant clears.
+ scissorState.setDisabled();
+ } else {
+ // Unlike with stencil clears, we also allow clears up to the logical dimensions of the
+ // render target to overflow into any approx-fit padding of the backing store dimensions
+ scissorState.relaxTest(this->dimensions());
+ }
+ }
+
+ if (!scissorState.enabled()) {
+ // This is a fullscreen clear, so could be handled as a load op. Regardless, we can also
+ // discard all prior ops in the current task since the color buffer will be overwritten.
+ GrOpsTask* opsTask = this->getOpsTask();
+ if (opsTask->resetForFullscreenClear(this->canDiscardPreviousOpsOnFullClear()) &&
+ !this->caps()->performColorClearsAsDraws()) {
+ SkPMColor4f clearColor = this->writeSurfaceView().swizzle().applyTo(color);
+ // The op list was emptied and native clears are allowed, so just use the load op
+ opsTask->setColorLoadOp(GrLoadOp::kClear, clearColor.array());
+ return;
+ } else {
+ // Will use an op for the clear, reset the load op to discard since the op will
+ // blow away the color buffer contents
+ opsTask->setColorLoadOp(GrLoadOp::kDiscard);
+ }
+ }
+
+ // At this point we are either a partial clear or a fullscreen clear that couldn't be applied
+ // as a load op.
+ bool clearAsDraw = this->caps()->performColorClearsAsDraws() ||
+ (scissorState.enabled() && this->caps()->performPartialClearsAsDraws());
+ if (clearAsDraw) {
+ GrPaint paint;
+ clear_to_grpaint(color, &paint);
+ this->addDrawOp(nullptr,
+ GrFillRectOp::MakeNonAARect(fContext, std::move(paint), SkMatrix::I(),
+ SkRect::Make(scissorState.rect())));
+ } else {
+ SkPMColor4f clearColor = this->writeSurfaceView().swizzle().applyTo(color);
+ this->addOp(GrClearOp::MakeColor(fContext, scissorState, clearColor.array()));
+ }
+}
+
+void GrSurfaceDrawContext::drawPaint(const GrClip* clip,
+ GrPaint&& paint,
+ const SkMatrix& viewMatrix) {
+ // Start with the render target, since that is the maximum content we could possibly fill.
+ // drawFilledQuad() will automatically restrict it to clip bounds for us if possible.
+ SkRect r = this->asSurfaceProxy()->getBoundsRect();
+ if (!paint.numTotalFragmentProcessors()) {
+ // The paint is trivial so we won't need to use local coordinates, so skip calculating the
+ // inverse view matrix.
+ this->fillRectToRect(clip, std::move(paint), GrAA::kNo, SkMatrix::I(), r, r);
+ } else {
+ // Use the inverse view matrix to arrive at appropriate local coordinates for the paint.
+ SkMatrix localMatrix;
+ if (!viewMatrix.invert(&localMatrix)) {
+ return;
+ }
+ this->fillRectWithLocalMatrix(clip, std::move(paint), GrAA::kNo, SkMatrix::I(), r,
+ localMatrix);
+ }
+}
+
+enum class GrSurfaceDrawContext::QuadOptimization {
+ // The rect to draw doesn't intersect clip or render target, so no draw op should be added
+ kDiscarded,
+ // The rect to draw was converted to some other op and appended to the oplist, so no additional
+ // op is necessary. Currently this can convert it to a clear op or a rrect op. Only valid if
+ // a constColor is provided.
+ kSubmitted,
+ // The clip was folded into the device quad, with updated edge flags and local coords, and
+ // caller is responsible for adding an appropriate op.
+ kClipApplied,
+ // No change to clip, but quad updated to better fit clip/render target, and caller is
+ // responsible for adding an appropriate op.
+ kCropped
+};
+
+GrSurfaceDrawContext::QuadOptimization GrSurfaceDrawContext::attemptQuadOptimization(
+ const GrClip* clip, const SkPMColor4f* constColor,
+ const GrUserStencilSettings* stencilSettings, GrAA* aa, DrawQuad* quad) {
+ // Optimization requirements:
+ // 1. kDiscard applies when clip bounds and quad bounds do not intersect
+ // 2a. kSubmitted applies when constColor and final geom is pixel aligned rect;
+ // pixel aligned rect requires rect clip and (rect quad or quad covers clip) OR
+ // 2b. kSubmitted applies when constColor and rrect clip and quad covers clip
+ // 4. kClipApplied applies when rect clip and (rect quad or quad covers clip)
+ // 5. kCropped in all other scenarios (although a crop may be a no-op)
+
+ // Save the old AA flags since CropToRect will modify 'quad' and if kCropped is returned, it's
+ // better to just keep the old flags instead of introducing mixed edge flags.
+ GrQuadAAFlags oldFlags = quad->fEdgeFlags;
+
+ // Use the logical size of the render target, which allows for "fullscreen" clears even if
+ // the render target has an approximate backing fit
+ SkRect rtRect = this->asSurfaceProxy()->getBoundsRect();
+
+ SkRect drawBounds = quad->fDevice.bounds();
+ if (!quad->fDevice.isFinite() || drawBounds.isEmpty() ||
+ GrClip::IsOutsideClip(rtRect, drawBounds)) {
+ return QuadOptimization::kDiscarded;
+ }
+ auto conservativeCrop = [&]() {
+ static constexpr int kLargeDrawLimit = 15000;
+ // Crop the quad to the render target. This doesn't change the visual results of drawing but
+ // is meant to help numerical stability for excessively large draws.
+ if (drawBounds.width() > kLargeDrawLimit || drawBounds.height() > kLargeDrawLimit) {
+ GrQuadUtils::CropToRect(rtRect, *aa, quad, /* compute local */ !constColor);
+ SkASSERT(quad->fEdgeFlags == oldFlags);
+ }
+ };
+
+ bool simpleColor = !stencilSettings && constColor;
+ GrClip::PreClipResult result = clip ? clip->preApply(drawBounds, *aa)
+ : GrClip::PreClipResult(GrClip::Effect::kUnclipped);
+ switch(result.fEffect) {
+ case GrClip::Effect::kClippedOut:
+ return QuadOptimization::kDiscarded;
+ case GrClip::Effect::kUnclipped:
+ if (!simpleColor) {
+ conservativeCrop();
+ return QuadOptimization::kClipApplied;
+ } else {
+ // Update result to store the render target bounds in order and then fall
+ // through to attempt the draw->native clear optimization
+ result = GrClip::PreClipResult(SkRRect::MakeRect(rtRect), *aa);
+ }
+ break;
+ case GrClip::Effect::kClipped:
+ if (!result.fIsRRect || (stencilSettings && result.fAA != *aa) ||
+ (!result.fRRect.isRect() && !simpleColor)) {
+ // The clip and draw state are too complicated to try and reduce
+ conservativeCrop();
+ return QuadOptimization::kCropped;
+ } // Else fall through to attempt to combine the draw and clip geometry together
+ break;
+ default:
+ SkUNREACHABLE;
+ }
+
+ // If we reached here, we know we're an axis-aligned clip that is either a rect or a round rect,
+ // so we can potentially combine it with the draw geometry so that no clipping is needed.
+ SkASSERT(result.fEffect == GrClip::Effect::kClipped && result.fIsRRect);
+ SkRect clippedBounds = result.fRRect.getBounds();
+ clippedBounds.intersect(rtRect);
+ if (result.fRRect.isRect()) {
+ // No rounded corners, so we might be able to become a native clear or we might be able to
+ // modify geometry and edge flags to represent intersected shape of clip and draw.
+ if (GrQuadUtils::CropToRect(clippedBounds, result.fAA, quad,
+ /*compute local*/ !constColor)) {
+ if (simpleColor && quad->fDevice.quadType() == GrQuad::Type::kAxisAligned) {
+ // Clear optimization is possible
+ drawBounds = quad->fDevice.bounds();
+ if (drawBounds.contains(rtRect)) {
+ // Fullscreen clear
+ this->clear(*constColor);
+ return QuadOptimization::kSubmitted;
+ } else if (GrClip::IsPixelAligned(drawBounds) &&
+ drawBounds.width() > 256 && drawBounds.height() > 256) {
+ // Scissor + clear (round shouldn't do anything since we are pixel aligned)
+ SkIRect scissorRect;
+ drawBounds.round(&scissorRect);
+ this->clear(scissorRect, *constColor);
+ return QuadOptimization::kSubmitted;
+ }
+ }
+
+ // else the draw and clip were combined so just update the AA to reflect combination
+ if (*aa == GrAA::kNo && result.fAA == GrAA::kYes &&
+ quad->fEdgeFlags != GrQuadAAFlags::kNone) {
+ // The clip was anti-aliased and now the draw needs to be upgraded to AA to
+ // properly reflect the smooth edge of the clip.
+ *aa = GrAA::kYes;
+ }
+ // We intentionally do not downgrade AA here because we don't know if we need to
+ // preserve MSAA (see GrQuadAAFlags docs). But later in the pipeline, the ops can
+ // use GrResolveAATypeForQuad() to turn off coverage AA when all flags are off.
+ // deviceQuad is exactly the intersection of original quad and clip, so it can be
+ // drawn with no clip (submitted by caller)
+ return QuadOptimization::kClipApplied;
+ }
+ } else {
+ // Rounded corners and constant filled color (limit ourselves to solid colors because
+ // there is no way to use custom local coordinates with drawRRect).
+ SkASSERT(simpleColor);
+ if (GrQuadUtils::CropToRect(clippedBounds, result.fAA, quad,
+ /* compute local */ false) &&
+ quad->fDevice.quadType() == GrQuad::Type::kAxisAligned &&
+ quad->fDevice.bounds().contains(clippedBounds)) {
+ // Since the cropped quad became a rectangle which covered the bounds of the rrect,
+ // we can draw the rrect directly and ignore the edge flags
+ GrPaint paint;
+ clear_to_grpaint(*constColor, &paint);
+ this->drawRRect(nullptr, std::move(paint), result.fAA, SkMatrix::I(), result.fRRect,
+ GrStyle::SimpleFill());
+ return QuadOptimization::kSubmitted;
+ }
+ }
+
+ // The quads have been updated to better fit the clip bounds, but can't get rid of
+ // the clip entirely
+ quad->fEdgeFlags = oldFlags;
+ return QuadOptimization::kCropped;
+}
+
+void GrSurfaceDrawContext::drawFilledQuad(const GrClip* clip,
+ GrPaint&& paint,
+ GrAA aa,
+ DrawQuad* quad,
+ const GrUserStencilSettings* ss) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawFilledQuad", fContext);
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ SkPMColor4f* constColor = nullptr;
+ SkPMColor4f paintColor;
+ if (!ss && !paint.hasCoverageFragmentProcessor() && paint.isConstantBlendedColor(&paintColor)) {
+ // Only consider clears/rrects when it's easy to guarantee 100% fill with single color
+ constColor = &paintColor;
+ }
+
+ QuadOptimization opt = this->attemptQuadOptimization(clip, constColor, ss, &aa, quad);
+ if (opt >= QuadOptimization::kClipApplied) {
+ // These optimizations require caller to add an op themselves
+ const GrClip* finalClip = opt == QuadOptimization::kClipApplied ? nullptr : clip;
+ GrAAType aaType = ss ? (aa == GrAA::kYes ? GrAAType::kMSAA : GrAAType::kNone)
+ : this->chooseAAType(aa);
+ this->addDrawOp(finalClip, GrFillRectOp::Make(fContext, std::move(paint), aaType,
+ quad, ss));
+ }
+ // All other optimization levels were completely handled inside attempt(), so no extra op needed
+}
+
+void GrSurfaceDrawContext::drawTexturedQuad(const GrClip* clip,
+ GrSurfaceProxyView proxyView,
+ SkAlphaType srcAlphaType,
+ sk_sp<GrColorSpaceXform> textureXform,
+ GrSamplerState::Filter filter,
+ GrSamplerState::MipmapMode mm,
+ const SkPMColor4f& color,
+ SkBlendMode blendMode,
+ GrAA aa,
+ DrawQuad* quad,
+ const SkRect* subset) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ SkASSERT(proxyView.asTextureProxy());
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawTexturedQuad", fContext);
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ // Functionally this is very similar to drawFilledQuad except that there's no constColor to
+ // enable the kSubmitted optimizations, no stencil settings support, and its a GrTextureOp.
+ QuadOptimization opt = this->attemptQuadOptimization(clip, nullptr, nullptr, &aa, quad);
+
+ SkASSERT(opt != QuadOptimization::kSubmitted);
+ if (opt != QuadOptimization::kDiscarded) {
+ // And the texture op if not discarded
+ const GrClip* finalClip = opt == QuadOptimization::kClipApplied ? nullptr : clip;
+ GrAAType aaType = this->chooseAAType(aa);
+ auto clampType = GrColorTypeClampType(this->colorInfo().colorType());
+ auto saturate = clampType == GrClampType::kManual ? GrTextureOp::Saturate::kYes
+ : GrTextureOp::Saturate::kNo;
+ // Use the provided subset, although hypothetically we could detect that the cropped local
+ // quad is sufficiently inside the subset and the constraint could be dropped.
+ this->addDrawOp(finalClip,
+ GrTextureOp::Make(fContext, std::move(proxyView), srcAlphaType,
+ std::move(textureXform), filter, mm, color, saturate,
+ blendMode, aaType, quad, subset));
+ }
+}
+
+void GrSurfaceDrawContext::drawRect(const GrClip* clip,
+ GrPaint&& paint,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const SkRect& rect,
+ const GrStyle* style) {
+ if (!style) {
+ style = &GrStyle::SimpleFill();
+ }
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawRect", fContext);
+
+ // Path effects should've been devolved to a path in SkGpuDevice
+ SkASSERT(!style->pathEffect());
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ const SkStrokeRec& stroke = style->strokeRec();
+ if (stroke.getStyle() == SkStrokeRec::kFill_Style) {
+ // Fills the rect, using rect as its own local coordinates
+ this->fillRectToRect(clip, std::move(paint), aa, viewMatrix, rect, rect);
+ return;
+ } else if ((stroke.getStyle() == SkStrokeRec::kStroke_Style ||
+ stroke.getStyle() == SkStrokeRec::kHairline_Style) &&
+ (rect.width() && rect.height())) {
+ // Only use the StrokeRectOp for non-empty rectangles. Empty rectangles will be processed by
+ // GrStyledShape to handle stroke caps and dashing properly.
+ GrAAType aaType = this->chooseAAType(aa);
+ GrOp::Owner op = GrStrokeRectOp::Make(
+ fContext, std::move(paint), aaType, viewMatrix, rect, stroke);
+ // op may be null if the stroke is not supported or if using coverage aa and the view matrix
+ // does not preserve rectangles.
+ if (op) {
+ this->addDrawOp(clip, std::move(op));
+ return;
+ }
+ }
+ assert_alive(paint);
+ this->drawShapeUsingPathRenderer(clip, std::move(paint), aa, viewMatrix,
+ GrStyledShape(rect, *style));
+}
+
+void GrSurfaceDrawContext::drawQuadSet(const GrClip* clip,
+ GrPaint&& paint,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const QuadSetEntry quads[],
+ int cnt) {
+ GrAAType aaType = this->chooseAAType(aa);
+
+ GrFillRectOp::AddFillRectOps(this, clip, fContext, std::move(paint), aaType, viewMatrix,
+ quads, cnt);
+}
+
+int GrSurfaceDrawContext::maxWindowRectangles() const {
+ return this->asRenderTargetProxy()->maxWindowRectangles(*this->caps());
+}
+
+GrOpsTask::CanDiscardPreviousOps GrSurfaceDrawContext::canDiscardPreviousOpsOnFullClear() const {
+#if GR_TEST_UTILS
+ if (fPreserveOpsOnFullClear_TestingOnly) {
+ return GrOpsTask::CanDiscardPreviousOps::kNo;
+ }
+#endif
+ // Regardless of how the clear is implemented (native clear or a fullscreen quad), all prior ops
+ // would normally be overwritten. The one exception is if the render target context is marked as
+ // needing a stencil buffer then there may be a prior op that writes to the stencil buffer.
+ // Although the clear will ignore the stencil buffer, following draw ops may not so we can't get
+ // rid of all the preceding ops. Beware! If we ever add any ops that have a side effect beyond
+ // modifying the stencil buffer we will need a more elaborate tracking system (skbug.com/7002).
+ return GrOpsTask::CanDiscardPreviousOps(!fNumStencilSamples);
+}
+
+void GrSurfaceDrawContext::setNeedsStencil(bool useMixedSamplesIfNotMSAA) {
+ // Don't clear stencil until after we've changed fNumStencilSamples. This ensures we don't loop
+ // forever in the event that there are driver bugs and we need to clear as a draw.
+ bool hasInitializedStencil = fNumStencilSamples > 0;
+
+ int numRequiredSamples = this->numSamples();
+ if (useMixedSamplesIfNotMSAA && 1 == numRequiredSamples) {
+ SkASSERT(this->asRenderTargetProxy()->canUseMixedSamples(*this->caps()));
+ numRequiredSamples = this->caps()->internalMultisampleCount(
+ this->asSurfaceProxy()->backendFormat());
+ }
+ SkASSERT(numRequiredSamples > 0);
+
+ if (numRequiredSamples > fNumStencilSamples) {
+ fNumStencilSamples = numRequiredSamples;
+ this->asRenderTargetProxy()->setNeedsStencil(fNumStencilSamples);
+ }
+
+ if (!hasInitializedStencil) {
+ if (this->caps()->performStencilClearsAsDraws()) {
+ // There is a driver bug with clearing stencil. We must use an op to manually clear the
+ // stencil buffer before the op that required 'setNeedsStencil'.
+ this->internalStencilClear(nullptr, /* inside mask */ false);
+ } else {
+ this->getOpsTask()->setInitialStencilContent(
+ GrOpsTask::StencilContent::kUserBitsCleared);
+ }
+ }
+}
+
+void GrSurfaceDrawContext::internalStencilClear(const SkIRect* scissor, bool insideStencilMask) {
+ this->setNeedsStencil(/* useMixedSamplesIfNotMSAA = */ false);
+
+ GrScissorState scissorState(this->asSurfaceProxy()->backingStoreDimensions());
+ if (scissor && !scissorState.set(*scissor)) {
+ // The requested clear region is off screen, so nothing to do.
+ return;
+ }
+
+ bool clearWithDraw = this->caps()->performStencilClearsAsDraws() ||
+ (scissorState.enabled() && this->caps()->performPartialClearsAsDraws());
+ if (clearWithDraw) {
+ const GrUserStencilSettings* ss = GrStencilSettings::SetClipBitSettings(insideStencilMask);
+
+ // Configure the paint to have no impact on the color buffer
+ GrPaint paint;
+ paint.setXPFactory(GrDisableColorXPFactory::Get());
+ this->addDrawOp(nullptr,
+ GrFillRectOp::MakeNonAARect(fContext, std::move(paint), SkMatrix::I(),
+ SkRect::Make(scissorState.rect()), ss));
+ } else {
+ this->addOp(GrClearOp::MakeStencilClip(fContext, scissorState, insideStencilMask));
+ }
+}
+
+void GrSurfaceDrawContext::stencilPath(const GrHardClip* clip,
+ GrAA doStencilMSAA,
+ const SkMatrix& viewMatrix,
+ sk_sp<const GrPath> path) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "stencilPath", fContext);
+
+ // TODO: extract portions of checkDraw that are relevant to path stenciling.
+ SkASSERT(path);
+ SkASSERT(this->caps()->shaderCaps()->pathRenderingSupport());
+
+ // FIXME: Use path bounds instead of this WAR once
+ // https://bugs.chromium.org/p/skia/issues/detail?id=5640 is resolved.
+ SkIRect bounds = SkIRect::MakeSize(this->dimensions());
+
+ // Setup clip and reject offscreen paths; we do this explicitly instead of relying on addDrawOp
+ // because GrStencilPathOp is not a draw op as its state depends directly on the choices made
+ // during this clip application.
+ GrAppliedHardClip appliedClip(this->dimensions(),
+ this->asSurfaceProxy()->backingStoreDimensions());
+
+ if (clip && GrClip::Effect::kClippedOut == clip->apply(&appliedClip, &bounds)) {
+ return;
+ }
+ // else see FIXME above; we'd normally want to check path bounds with render target bounds,
+ // but as it is, we're just using the full render target so intersecting the two bounds would
+ // do nothing.
+
+ GrOp::Owner op = GrStencilPathOp::Make(fContext,
+ viewMatrix,
+ doStencilMSAA == GrAA::kYes,
+ appliedClip.hasStencilClip(),
+ appliedClip.scissorState(),
+ std::move(path));
+ if (!op) {
+ return;
+ }
+ op->setClippedBounds(SkRect::Make(bounds));
+
+ this->setNeedsStencil(GrAA::kYes == doStencilMSAA);
+ this->addOp(std::move(op));
+}
+
+void GrSurfaceDrawContext::drawTextureSet(const GrClip* clip,
+ TextureSetEntry set[],
+ int cnt,
+ int proxyRunCnt,
+ GrSamplerState::Filter filter,
+ GrSamplerState::MipmapMode mm,
+ SkBlendMode mode,
+ GrAA aa,
+ SkCanvas::SrcRectConstraint constraint,
+ const SkMatrix& viewMatrix,
+ sk_sp<GrColorSpaceXform> texXform) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawTextureSet", fContext);
+
+ // Create the minimum number of GrTextureOps needed to draw this set. Individual
+ // GrTextureOps can rebind the texture between draws thus avoiding GrPaint (re)creation.
+ AutoCheckFlush acf(this->drawingManager());
+ GrAAType aaType = this->chooseAAType(aa);
+ auto clampType = GrColorTypeClampType(this->colorInfo().colorType());
+ auto saturate = clampType == GrClampType::kManual ? GrTextureOp::Saturate::kYes
+ : GrTextureOp::Saturate::kNo;
+ GrTextureOp::AddTextureSetOps(this, clip, fContext, set, cnt, proxyRunCnt, filter, mm, saturate,
+ mode, aaType, constraint, viewMatrix, std::move(texXform));
+}
+
+void GrSurfaceDrawContext::drawVertices(const GrClip* clip,
+ GrPaint&& paint,
+ const SkMatrixProvider& matrixProvider,
+ sk_sp<SkVertices> vertices,
+ GrPrimitiveType* overridePrimType,
+ const SkRuntimeEffect* effect) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawVertices", fContext);
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ SkASSERT(vertices);
+ GrAAType aaType = this->chooseAAType(GrAA::kNo);
+ GrOp::Owner op =
+ GrDrawVerticesOp::Make(fContext, std::move(paint), std::move(vertices), matrixProvider,
+ aaType, this->colorInfo().refColorSpaceXformFromSRGB(),
+ overridePrimType, effect);
+ this->addDrawOp(clip, std::move(op));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void GrSurfaceDrawContext::drawAtlas(const GrClip* clip,
+ GrPaint&& paint,
+ const SkMatrix& viewMatrix,
+ int spriteCount,
+ const SkRSXform xform[],
+ const SkRect texRect[],
+ const SkColor colors[]) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawAtlas", fContext);
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ GrAAType aaType = this->chooseAAType(GrAA::kNo);
+ GrOp::Owner op = GrDrawAtlasOp::Make(fContext, std::move(paint), viewMatrix,
+ aaType, spriteCount, xform, texRect, colors);
+ this->addDrawOp(clip, std::move(op));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void GrSurfaceDrawContext::drawRRect(const GrClip* origClip,
+ GrPaint&& paint,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const SkRRect& rrect,
+ const GrStyle& style) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawRRect", fContext);
+
+ SkASSERT(!style.pathEffect()); // this should've been devolved to a path in SkGpuDevice
+
+ const SkStrokeRec& stroke = style.strokeRec();
+ if (stroke.getStyle() == SkStrokeRec::kFill_Style && rrect.isEmpty()) {
+ return;
+ }
+
+ const GrClip* clip = origClip;
+ // It is not uncommon to clip to a round rect and then draw that same round rect. Since our
+ // lower level clip code works from op bounds, which are SkRects, it doesn't detect that the
+ // clip can be ignored. The following test attempts to mitigate the stencil clip cost but only
+ // works for axis-aligned round rects. This also only works for filled rrects since the stroke
+ // width outsets beyond the rrect itself.
+ // TODO: skbug.com/10462 - There was mixed performance wins and regressions when this
+ // optimization was turned on outside of Android Framework. I (michaelludwig) believe this is
+ // do to the overhead in determining if an SkClipStack is just a rrect. Once that is improved,
+ // re-enable this and see if we avoid the regressions.
+#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
+ SkRRect devRRect;
+ if (clip && stroke.getStyle() == SkStrokeRec::kFill_Style &&
+ rrect.transform(viewMatrix, &devRRect)) {
+ GrClip::PreClipResult result = clip->preApply(devRRect.getBounds(), aa);
+ switch(result.fEffect) {
+ case GrClip::Effect::kClippedOut:
+ return;
+ case GrClip::Effect::kUnclipped:
+ clip = nullptr;
+ break;
+ case GrClip::Effect::kClipped:
+ // Currently there's no general-purpose rrect-to-rrect contains function, and if we
+ // got here, we know the devRRect's bounds aren't fully contained by the clip.
+ // Testing for equality between the two is a reasonable stop-gap for now.
+ if (result.fIsRRect && result.fRRect == devRRect) {
+ // NOTE: On the android framework, we allow this optimization even when the clip
+ // is non-AA and the draw is AA.
+ if (result.fAA == aa || (result.fAA == GrAA::kNo && aa == GrAA::kYes)) {
+ clip = nullptr;
+ }
+ }
+ break;
+ default:
+ SkUNREACHABLE;
+ }
+ }
+#endif
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ GrAAType aaType = this->chooseAAType(aa);
+
+ GrOp::Owner op;
+ if (GrAAType::kCoverage == aaType && rrect.isSimple() &&
+ rrect.getSimpleRadii().fX == rrect.getSimpleRadii().fY &&
+ viewMatrix.rectStaysRect() && viewMatrix.isSimilarity()) {
+ // In coverage mode, we draw axis-aligned circular roundrects with the GrOvalOpFactory
+ // to avoid perf regressions on some platforms.
+ assert_alive(paint);
+ op = GrOvalOpFactory::MakeCircularRRectOp(
+ fContext, std::move(paint), viewMatrix, rrect, stroke, this->caps()->shaderCaps());
+ }
+ if (!op && style.isSimpleFill()) {
+ assert_alive(paint);
+ op = GrFillRRectOp::Make(fContext, std::move(paint), viewMatrix, rrect, aaType);
+ }
+ if (!op && GrAAType::kCoverage == aaType) {
+ assert_alive(paint);
+ op = GrOvalOpFactory::MakeRRectOp(
+ fContext, std::move(paint), viewMatrix, rrect, stroke, this->caps()->shaderCaps());
+ }
+ if (op) {
+ this->addDrawOp(clip, std::move(op));
+ return;
+ }
+
+ assert_alive(paint);
+ this->drawShapeUsingPathRenderer(clip, std::move(paint), aa, viewMatrix,
+ GrStyledShape(rrect, style));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static SkPoint3 map(const SkMatrix& m, const SkPoint3& pt) {
+ SkPoint3 result;
+ m.mapXY(pt.fX, pt.fY, (SkPoint*)&result.fX);
+ result.fZ = pt.fZ;
+ return result;
+}
+
+bool GrSurfaceDrawContext::drawFastShadow(const GrClip* clip,
+ const SkMatrix& viewMatrix,
+ const SkPath& path,
+ const SkDrawShadowRec& rec) {
+ ASSERT_SINGLE_OWNER
+ if (fContext->abandoned()) {
+ return true;
+ }
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawFastShadow", fContext);
+
+ // check z plane
+ bool tiltZPlane = SkToBool(!SkScalarNearlyZero(rec.fZPlaneParams.fX) ||
+ !SkScalarNearlyZero(rec.fZPlaneParams.fY));
+ bool skipAnalytic = SkToBool(rec.fFlags & SkShadowFlags::kGeometricOnly_ShadowFlag);
+ if (tiltZPlane || skipAnalytic || !viewMatrix.rectStaysRect() || !viewMatrix.isSimilarity()) {
+ return false;
+ }
+
+ SkRRect rrect;
+ SkRect rect;
+ // we can only handle rects, circles, and rrects with circular corners
+ bool isRRect = path.isRRect(&rrect) && SkRRectPriv::IsSimpleCircular(rrect) &&
+ rrect.radii(SkRRect::kUpperLeft_Corner).fX > SK_ScalarNearlyZero;
+ if (!isRRect &&
+ path.isOval(&rect) && SkScalarNearlyEqual(rect.width(), rect.height()) &&
+ rect.width() > SK_ScalarNearlyZero) {
+ rrect.setOval(rect);
+ isRRect = true;
+ }
+ if (!isRRect && path.isRect(&rect)) {
+ rrect.setRect(rect);
+ isRRect = true;
+ }
+
+ if (!isRRect) {
+ return false;
+ }
+
+ if (rrect.isEmpty()) {
+ return true;
+ }
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ // transform light
+ SkPoint3 devLightPos = map(viewMatrix, rec.fLightPos);
+
+ // 1/scale
+ SkScalar devToSrcScale = viewMatrix.isScaleTranslate() ?
+ SkScalarInvert(SkScalarAbs(viewMatrix[SkMatrix::kMScaleX])) :
+ sk_float_rsqrt(viewMatrix[SkMatrix::kMScaleX] * viewMatrix[SkMatrix::kMScaleX] +
+ viewMatrix[SkMatrix::kMSkewX] * viewMatrix[SkMatrix::kMSkewX]);
+
+ SkScalar occluderHeight = rec.fZPlaneParams.fZ;
+ bool transparent = SkToBool(rec.fFlags & SkShadowFlags::kTransparentOccluder_ShadowFlag);
+
+ if (SkColorGetA(rec.fAmbientColor) > 0) {
+ SkScalar devSpaceInsetWidth = SkDrawShadowMetrics::AmbientBlurRadius(occluderHeight);
+ const SkScalar umbraRecipAlpha = SkDrawShadowMetrics::AmbientRecipAlpha(occluderHeight);
+ const SkScalar devSpaceAmbientBlur = devSpaceInsetWidth * umbraRecipAlpha;
+
+ // Outset the shadow rrect to the border of the penumbra
+ SkScalar ambientPathOutset = devSpaceInsetWidth * devToSrcScale;
+ SkRRect ambientRRect;
+ SkRect outsetRect = rrect.rect().makeOutset(ambientPathOutset, ambientPathOutset);
+ // If the rrect was an oval then its outset will also be one.
+ // We set it explicitly to avoid errors.
+ if (rrect.isOval()) {
+ ambientRRect = SkRRect::MakeOval(outsetRect);
+ } else {
+ SkScalar outsetRad = SkRRectPriv::GetSimpleRadii(rrect).fX + ambientPathOutset;
+ ambientRRect = SkRRect::MakeRectXY(outsetRect, outsetRad, outsetRad);
+ }
+
+ GrColor ambientColor = SkColorToPremulGrColor(rec.fAmbientColor);
+ if (transparent) {
+ // set a large inset to force a fill
+ devSpaceInsetWidth = ambientRRect.width();
+ }
+
+ GrOp::Owner op = GrShadowRRectOp::Make(fContext,
+ ambientColor,
+ viewMatrix,
+ ambientRRect,
+ devSpaceAmbientBlur,
+ devSpaceInsetWidth);
+ if (op) {
+ this->addDrawOp(clip, std::move(op));
+ }
+ }
+
+ if (SkColorGetA(rec.fSpotColor) > 0) {
+ SkScalar devSpaceSpotBlur;
+ SkScalar spotScale;
+ SkVector spotOffset;
+ SkDrawShadowMetrics::GetSpotParams(occluderHeight, devLightPos.fX, devLightPos.fY,
+ devLightPos.fZ, rec.fLightRadius,
+ &devSpaceSpotBlur, &spotScale, &spotOffset);
+ // handle scale of radius due to CTM
+ const SkScalar srcSpaceSpotBlur = devSpaceSpotBlur * devToSrcScale;
+
+ // Adjust translate for the effect of the scale.
+ spotOffset.fX += spotScale*viewMatrix[SkMatrix::kMTransX];
+ spotOffset.fY += spotScale*viewMatrix[SkMatrix::kMTransY];
+ // This offset is in dev space, need to transform it into source space.
+ SkMatrix ctmInverse;
+ if (viewMatrix.invert(&ctmInverse)) {
+ ctmInverse.mapPoints(&spotOffset, 1);
+ } else {
+ // Since the matrix is a similarity, this should never happen, but just in case...
+ SkDebugf("Matrix is degenerate. Will not render spot shadow correctly!\n");
+ SkASSERT(false);
+ }
+
+ // Compute the transformed shadow rrect
+ SkRRect spotShadowRRect;
+ SkMatrix shadowTransform;
+ shadowTransform.setScaleTranslate(spotScale, spotScale, spotOffset.fX, spotOffset.fY);
+ rrect.transform(shadowTransform, &spotShadowRRect);
+ SkScalar spotRadius = SkRRectPriv::GetSimpleRadii(spotShadowRRect).fX;
+
+ // Compute the insetWidth
+ SkScalar blurOutset = srcSpaceSpotBlur;
+ SkScalar insetWidth = blurOutset;
+ if (transparent) {
+ // If transparent, just do a fill
+ insetWidth += spotShadowRRect.width();
+ } else {
+ // For shadows, instead of using a stroke we specify an inset from the penumbra
+ // border. We want to extend this inset area so that it meets up with the caster
+ // geometry. The inset geometry will by default already be inset by the blur width.
+ //
+ // We compare the min and max corners inset by the radius between the original
+ // rrect and the shadow rrect. The distance between the two plus the difference
+ // between the scaled radius and the original radius gives the distance from the
+ // transformed shadow shape to the original shape in that corner. The max
+ // of these gives the maximum distance we need to cover.
+ //
+ // Since we are outsetting by 1/2 the blur distance, we just add the maxOffset to
+ // that to get the full insetWidth.
+ SkScalar maxOffset;
+ if (rrect.isRect()) {
+ // Manhattan distance works better for rects
+ maxOffset = std::max(std::max(SkTAbs(spotShadowRRect.rect().fLeft -
+ rrect.rect().fLeft),
+ SkTAbs(spotShadowRRect.rect().fTop -
+ rrect.rect().fTop)),
+ std::max(SkTAbs(spotShadowRRect.rect().fRight -
+ rrect.rect().fRight),
+ SkTAbs(spotShadowRRect.rect().fBottom -
+ rrect.rect().fBottom)));
+ } else {
+ SkScalar dr = spotRadius - SkRRectPriv::GetSimpleRadii(rrect).fX;
+ SkPoint upperLeftOffset = SkPoint::Make(spotShadowRRect.rect().fLeft -
+ rrect.rect().fLeft + dr,
+ spotShadowRRect.rect().fTop -
+ rrect.rect().fTop + dr);
+ SkPoint lowerRightOffset = SkPoint::Make(spotShadowRRect.rect().fRight -
+ rrect.rect().fRight - dr,
+ spotShadowRRect.rect().fBottom -
+ rrect.rect().fBottom - dr);
+ maxOffset = SkScalarSqrt(std::max(SkPointPriv::LengthSqd(upperLeftOffset),
+ SkPointPriv::LengthSqd(lowerRightOffset))) + dr;
+ }
+ insetWidth += std::max(blurOutset, maxOffset);
+ }
+
+ // Outset the shadow rrect to the border of the penumbra
+ SkRect outsetRect = spotShadowRRect.rect().makeOutset(blurOutset, blurOutset);
+ if (spotShadowRRect.isOval()) {
+ spotShadowRRect = SkRRect::MakeOval(outsetRect);
+ } else {
+ SkScalar outsetRad = spotRadius + blurOutset;
+ spotShadowRRect = SkRRect::MakeRectXY(outsetRect, outsetRad, outsetRad);
+ }
+
+ GrColor spotColor = SkColorToPremulGrColor(rec.fSpotColor);
+
+ GrOp::Owner op = GrShadowRRectOp::Make(fContext,
+ spotColor,
+ viewMatrix,
+ spotShadowRRect,
+ 2.0f * devSpaceSpotBlur,
+ insetWidth);
+ if (op) {
+ this->addDrawOp(clip, std::move(op));
+ }
+ }
+
+ return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool GrSurfaceDrawContext::drawFilledDRRect(const GrClip* clip,
+ GrPaint&& paint,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const SkRRect& origOuter,
+ const SkRRect& origInner) {
+ SkASSERT(!origInner.isEmpty());
+ SkASSERT(!origOuter.isEmpty());
+
+ SkTCopyOnFirstWrite<SkRRect> inner(origInner), outer(origOuter);
+
+ GrAAType aaType = this->chooseAAType(aa);
+
+ if (GrAAType::kMSAA == aaType) {
+ return false;
+ }
+
+ if (GrAAType::kCoverage == aaType && SkRRectPriv::IsCircle(*inner)
+ && SkRRectPriv::IsCircle(*outer)) {
+ auto outerR = outer->width() / 2.f;
+ auto innerR = inner->width() / 2.f;
+ auto cx = outer->getBounds().fLeft + outerR;
+ auto cy = outer->getBounds().fTop + outerR;
+ if (SkScalarNearlyEqual(cx, inner->getBounds().fLeft + innerR) &&
+ SkScalarNearlyEqual(cy, inner->getBounds().fTop + innerR)) {
+ auto avgR = (innerR + outerR) / 2.f;
+ auto circleBounds = SkRect::MakeLTRB(cx - avgR, cy - avgR, cx + avgR, cy + avgR);
+ SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
+ stroke.setStrokeStyle(outerR - innerR);
+ auto op = GrOvalOpFactory::MakeOvalOp(fContext, std::move(paint), viewMatrix,
+ circleBounds, GrStyle(stroke, nullptr),
+ this->caps()->shaderCaps());
+ if (op) {
+ this->addDrawOp(clip, std::move(op));
+ return true;
+ }
+ assert_alive(paint);
+ }
+ }
+
+ GrClipEdgeType innerEdgeType, outerEdgeType;
+ if (GrAAType::kCoverage == aaType) {
+ innerEdgeType = GrClipEdgeType::kInverseFillAA;
+ outerEdgeType = GrClipEdgeType::kFillAA;
+ } else {
+ innerEdgeType = GrClipEdgeType::kInverseFillBW;
+ outerEdgeType = GrClipEdgeType::kFillBW;
+ }
+
+ SkMatrix inverseVM;
+ if (!viewMatrix.isIdentity()) {
+ if (!origInner.transform(viewMatrix, inner.writable())) {
+ return false;
+ }
+ if (!origOuter.transform(viewMatrix, outer.writable())) {
+ return false;
+ }
+ if (!viewMatrix.invert(&inverseVM)) {
+ return false;
+ }
+ } else {
+ inverseVM.reset();
+ }
+
+ const auto& caps = *this->caps()->shaderCaps();
+ // TODO these need to be a geometry processors
+ auto [success, fp] = GrRRectEffect::Make(/*inputFP=*/nullptr, innerEdgeType, *inner, caps);
+ if (!success) {
+ return false;
+ }
+
+ std::tie(success, fp) = GrRRectEffect::Make(std::move(fp), outerEdgeType, *outer, caps);
+ if (!success) {
+ return false;
+ }
+
+ paint.setCoverageFragmentProcessor(std::move(fp));
+
+ SkRect bounds = outer->getBounds();
+ if (GrAAType::kCoverage == aaType) {
+ bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
+ }
+
+ this->fillRectWithLocalMatrix(clip, std::move(paint), GrAA::kNo, SkMatrix::I(), bounds,
+ inverseVM);
+ return true;
+}
+
+void GrSurfaceDrawContext::drawDRRect(const GrClip* clip,
+ GrPaint&& paint,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const SkRRect& outer,
+ const SkRRect& inner) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawDRRect", fContext);
+
+ SkASSERT(!outer.isEmpty());
+ SkASSERT(!inner.isEmpty());
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ if (this->drawFilledDRRect(clip, std::move(paint), aa, viewMatrix, outer, inner)) {
+ return;
+ }
+ assert_alive(paint);
+
+ SkPath path;
+ path.setIsVolatile(true);
+ path.addRRect(inner);
+ path.addRRect(outer);
+ path.setFillType(SkPathFillType::kEvenOdd);
+ this->drawShapeUsingPathRenderer(clip, std::move(paint), aa, viewMatrix, GrStyledShape(path));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void GrSurfaceDrawContext::drawRegion(const GrClip* clip,
+ GrPaint&& paint,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const SkRegion& region,
+ const GrStyle& style,
+ const GrUserStencilSettings* ss) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawRegion", fContext);
+
+ if (GrAA::kYes == aa) {
+ // GrRegionOp performs no antialiasing but is much faster, so here we check the matrix
+ // to see whether aa is really required.
+ if (!SkToBool(viewMatrix.getType() & ~(SkMatrix::kTranslate_Mask)) &&
+ SkScalarIsInt(viewMatrix.getTranslateX()) &&
+ SkScalarIsInt(viewMatrix.getTranslateY())) {
+ aa = GrAA::kNo;
+ }
+ }
+ bool complexStyle = !style.isSimpleFill();
+ if (complexStyle || GrAA::kYes == aa) {
+ SkPath path;
+ region.getBoundaryPath(&path);
+ path.setIsVolatile(true);
+
+ return this->drawPath(clip, std::move(paint), aa, viewMatrix, path, style);
+ }
+
+ GrAAType aaType = this->chooseAAType(GrAA::kNo);
+ GrOp::Owner op = GrRegionOp::Make(fContext, std::move(paint), viewMatrix, region,
+ aaType, ss);
+ this->addDrawOp(clip, std::move(op));
+}
+
+void GrSurfaceDrawContext::drawOval(const GrClip* clip,
+ GrPaint&& paint,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const SkRect& oval,
+ const GrStyle& style) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawOval", fContext);
+
+ const SkStrokeRec& stroke = style.strokeRec();
+
+ if (oval.isEmpty() && !style.pathEffect()) {
+ if (stroke.getStyle() == SkStrokeRec::kFill_Style) {
+ return;
+ }
+
+ this->drawRect(clip, std::move(paint), aa, viewMatrix, oval, &style);
+ return;
+ }
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ GrAAType aaType = this->chooseAAType(aa);
+
+ GrOp::Owner op;
+ if (GrAAType::kCoverage == aaType && oval.width() > SK_ScalarNearlyZero &&
+ oval.width() == oval.height() && viewMatrix.isSimilarity()) {
+ // We don't draw true circles as round rects in coverage mode, because it can
+ // cause perf regressions on some platforms as compared to the dedicated circle Op.
+ assert_alive(paint);
+ op = GrOvalOpFactory::MakeCircleOp(fContext, std::move(paint), viewMatrix, oval, style,
+ this->caps()->shaderCaps());
+ }
+ if (!op && style.isSimpleFill()) {
+ // GrFillRRectOp has special geometry and a fragment-shader branch to conditionally evaluate
+ // the arc equation. This same special geometry and fragment branch also turn out to be a
+ // substantial optimization for drawing ovals (namely, by not evaluating the arc equation
+ // inside the oval's inner diamond). Given these optimizations, it's a clear win to draw
+ // ovals the exact same way we do round rects.
+ assert_alive(paint);
+ op = GrFillRRectOp::Make(fContext, std::move(paint), viewMatrix, SkRRect::MakeOval(oval),
+ aaType);
+ }
+ if (!op && GrAAType::kCoverage == aaType) {
+ assert_alive(paint);
+ op = GrOvalOpFactory::MakeOvalOp(fContext, std::move(paint), viewMatrix, oval, style,
+ this->caps()->shaderCaps());
+ }
+ if (op) {
+ this->addDrawOp(clip, std::move(op));
+ return;
+ }
+
+ assert_alive(paint);
+ this->drawShapeUsingPathRenderer(
+ clip, std::move(paint), aa, viewMatrix,
+ GrStyledShape(SkRRect::MakeOval(oval), SkPathDirection::kCW, 2, false, style));
+}
+
+void GrSurfaceDrawContext::drawArc(const GrClip* clip,
+ GrPaint&& paint,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const SkRect& oval,
+ SkScalar startAngle,
+ SkScalar sweepAngle,
+ bool useCenter,
+ const GrStyle& style) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawArc", fContext);
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ GrAAType aaType = this->chooseAAType(aa);
+ if (GrAAType::kCoverage == aaType) {
+ const GrShaderCaps* shaderCaps = this->caps()->shaderCaps();
+ GrOp::Owner op = GrOvalOpFactory::MakeArcOp(fContext,
+ std::move(paint),
+ viewMatrix,
+ oval,
+ startAngle,
+ sweepAngle,
+ useCenter,
+ style,
+ shaderCaps);
+ if (op) {
+ this->addDrawOp(clip, std::move(op));
+ return;
+ }
+ assert_alive(paint);
+ }
+ this->drawShapeUsingPathRenderer(
+ clip, std::move(paint), aa, viewMatrix,
+ GrStyledShape::MakeArc(oval, startAngle, sweepAngle, useCenter, style));
+}
+
+void GrSurfaceDrawContext::drawImageLattice(const GrClip* clip,
+ GrPaint&& paint,
+ const SkMatrix& viewMatrix,
+ GrSurfaceProxyView view,
+ SkAlphaType alphaType,
+ sk_sp<GrColorSpaceXform> csxf,
+ GrSamplerState::Filter filter,
+ std::unique_ptr<SkLatticeIter> iter,
+ const SkRect& dst) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawImageLattice", fContext);
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ GrOp::Owner op =
+ GrLatticeOp::MakeNonAA(fContext, std::move(paint), viewMatrix, std::move(view),
+ alphaType, std::move(csxf), filter, std::move(iter), dst);
+ this->addDrawOp(clip, std::move(op));
+}
+
+void GrSurfaceDrawContext::drawDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler> drawable,
+ const SkRect& bounds) {
+ GrOp::Owner op(GrDrawableOp::Make(fContext, std::move(drawable), bounds));
+ SkASSERT(op);
+ this->addOp(std::move(op));
+}
+
+bool GrSurfaceDrawContext::waitOnSemaphores(int numSemaphores,
+ const GrBackendSemaphore waitSemaphores[],
+ bool deleteSemaphoresAfterWait) {
+ ASSERT_SINGLE_OWNER
+ RETURN_FALSE_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "waitOnSemaphores", fContext);
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ if (numSemaphores && !this->caps()->semaphoreSupport()) {
+ return false;
+ }
+
+ auto direct = fContext->asDirectContext();
+ if (!direct) {
+ return false;
+ }
+
+ auto resourceProvider = direct->priv().resourceProvider();
+
+ GrWrapOwnership ownership =
+ deleteSemaphoresAfterWait ? kAdopt_GrWrapOwnership : kBorrow_GrWrapOwnership;
+
+ std::unique_ptr<std::unique_ptr<GrSemaphore>[]> grSemaphores(
+ new std::unique_ptr<GrSemaphore>[numSemaphores]);
+ for (int i = 0; i < numSemaphores; ++i) {
+ grSemaphores[i] = resourceProvider->wrapBackendSemaphore(
+ waitSemaphores[i], GrResourceProvider::SemaphoreWrapType::kWillWait, ownership);
+ }
+ this->drawingManager()->newWaitRenderTask(this->asSurfaceProxyRef(), std::move(grSemaphores),
+ numSemaphores);
+ return true;
+}
+
+void GrSurfaceDrawContext::drawPath(const GrClip* clip,
+ GrPaint&& paint,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const SkPath& path,
+ const GrStyle& style) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawPath", fContext);
+
+ GrStyledShape shape(path, style);
+
+ this->drawShape(clip, std::move(paint), aa, viewMatrix, shape);
+}
+
+void GrSurfaceDrawContext::drawShape(const GrClip* clip,
+ GrPaint&& paint,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const GrStyledShape& shape) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawShape", fContext);
+
+ if (shape.isEmpty()) {
+ if (shape.inverseFilled()) {
+ this->drawPaint(clip, std::move(paint), viewMatrix);
+ }
+ return;
+ }
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ if (!shape.style().hasPathEffect()) {
+ GrAAType aaType = this->chooseAAType(aa);
+ SkRRect rrect;
+ // We can ignore the starting point and direction since there is no path effect.
+ bool inverted;
+ if (shape.asRRect(&rrect, nullptr, nullptr, &inverted) && !inverted) {
+ if (rrect.isRect()) {
+ this->drawRect(clip, std::move(paint), aa, viewMatrix, rrect.rect(),
+ &shape.style());
+ return;
+ } else if (rrect.isOval()) {
+ this->drawOval(clip, std::move(paint), aa, viewMatrix, rrect.rect(), shape.style());
+ return;
+ }
+ this->drawRRect(clip, std::move(paint), aa, viewMatrix, rrect, shape.style());
+ return;
+ } else if (GrAAType::kCoverage == aaType && shape.style().isSimpleFill() &&
+ viewMatrix.rectStaysRect()) {
+ // TODO: the rectStaysRect restriction could be lifted if we were willing to apply
+ // the matrix to all the points individually rather than just to the rect
+ SkRect rects[2];
+ if (shape.asNestedRects(rects)) {
+ // Concave AA paths are expensive - try to avoid them for special cases
+ GrOp::Owner op = GrStrokeRectOp::MakeNested(
+ fContext, std::move(paint), viewMatrix, rects);
+ if (op) {
+ this->addDrawOp(clip, std::move(op));
+ }
+ // Returning here indicates that there is nothing to draw in this case.
+ return;
+ }
+ }
+ }
+
+ // If we get here in drawShape(), we definitely need to use path rendering
+ this->drawShapeUsingPathRenderer(clip, std::move(paint), aa, viewMatrix, shape,
+ /* attempt fallback */ false);
+}
+
+static SkIRect get_clip_bounds(const GrSurfaceDrawContext* rtc, const GrClip* clip) {
+ return clip ? clip->getConservativeBounds() : SkIRect::MakeWH(rtc->width(), rtc->height());
+}
+
+bool GrSurfaceDrawContext::drawAndStencilPath(const GrHardClip* clip,
+ const GrUserStencilSettings* ss,
+ SkRegion::Op op,
+ bool invert,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const SkPath& path) {
+ ASSERT_SINGLE_OWNER
+ RETURN_FALSE_IF_ABANDONED
+ SkDEBUGCODE(this->validate();)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "drawAndStencilPath", fContext);
+
+ if (path.isEmpty() && path.isInverseFillType()) {
+ GrPaint paint;
+ paint.setCoverageSetOpXPFactory(op, invert);
+ this->stencilRect(clip, ss, std::move(paint), GrAA::kNo, SkMatrix::I(),
+ SkRect::Make(this->dimensions()));
+ return true;
+ }
+
+ AutoCheckFlush acf(this->drawingManager());
+
+ // An Assumption here is that path renderer would use some form of tweaking
+ // the src color (either the input alpha or in the frag shader) to implement
+ // aa. If we have some future driver-mojo path AA that can do the right
+ // thing WRT to the blend then we'll need some query on the PR.
+ GrAAType aaType = this->chooseAAType(aa);
+ bool hasUserStencilSettings = !ss->isUnused();
+
+ SkIRect clipConservativeBounds = get_clip_bounds(this, clip);
+
+ GrPaint paint;
+ paint.setCoverageSetOpXPFactory(op, invert);
+
+ GrStyledShape shape(path, GrStyle::SimpleFill());
+ GrPathRenderer::CanDrawPathArgs canDrawArgs;
+ canDrawArgs.fCaps = this->caps();
+ canDrawArgs.fProxy = this->asRenderTargetProxy();
+ canDrawArgs.fViewMatrix = &viewMatrix;
+ canDrawArgs.fShape = &shape;
+ canDrawArgs.fPaint = &paint;
+ canDrawArgs.fClipConservativeBounds = &clipConservativeBounds;
+ canDrawArgs.fAAType = aaType;
+ SkASSERT(!this->wrapsVkSecondaryCB());
+ canDrawArgs.fTargetIsWrappedVkSecondaryCB = false;
+ canDrawArgs.fHasUserStencilSettings = hasUserStencilSettings;
+
+ // Don't allow the SW renderer
+ GrPathRenderer* pr = this->drawingManager()->getPathRenderer(
+ canDrawArgs, false, GrPathRendererChain::DrawType::kStencilAndColor);
+ if (!pr) {
+ return false;
+ }
+
+ GrPathRenderer::DrawPathArgs args{this->drawingManager()->getContext(),
+ std::move(paint),
+ ss,
+ this,
+ clip,
+ &clipConservativeBounds,
+ &viewMatrix,
+ &shape,
+ aaType,
+ this->colorInfo().isLinearlyBlended()};
+ pr->drawPath(args);
+ return true;
+}
+
+SkBudgeted GrSurfaceDrawContext::isBudgeted() const {
+ ASSERT_SINGLE_OWNER
+
+ if (fContext->abandoned()) {
+ return SkBudgeted::kNo;
+ }
+
+ SkDEBUGCODE(this->validate();)
+
+ return this->asSurfaceProxy()->isBudgeted();
+}
+
+void GrSurfaceDrawContext::drawShapeUsingPathRenderer(const GrClip* clip,
+ GrPaint&& paint,
+ GrAA aa,
+ const SkMatrix& viewMatrix,
+ const GrStyledShape& originalShape,
+ bool attemptShapeFallback) {
+ ASSERT_SINGLE_OWNER
+ RETURN_IF_ABANDONED
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "internalDrawPath", fContext);
+
+ if (!viewMatrix.isFinite() || !originalShape.bounds().isFinite()) {
+ return;
+ }
+
+ if (attemptShapeFallback && originalShape.simplified()) {
+ // Usually we enter drawShapeUsingPathRenderer() because the shape+style was too
+ // complex for dedicated draw ops. However, if GrStyledShape was able to reduce something
+ // we ought to try again instead of going right to path rendering.
+ this->drawShape(clip, std::move(paint), aa, viewMatrix, originalShape);
+ return;
+ }
+
+ SkIRect clipConservativeBounds = get_clip_bounds(this, clip);
+
+ GrStyledShape tempShape;
+ GrAAType aaType = this->chooseAAType(aa);
+
+ GrPathRenderer::CanDrawPathArgs canDrawArgs;
+ canDrawArgs.fCaps = this->caps();
+ canDrawArgs.fProxy = this->asRenderTargetProxy();
+ canDrawArgs.fViewMatrix = &viewMatrix;
+ canDrawArgs.fShape = &originalShape;
+ canDrawArgs.fPaint = &paint;
+ canDrawArgs.fClipConservativeBounds = &clipConservativeBounds;
+ canDrawArgs.fTargetIsWrappedVkSecondaryCB = this->wrapsVkSecondaryCB();
+ canDrawArgs.fHasUserStencilSettings = false;
+
+ GrPathRenderer* pr;
+ static constexpr GrPathRendererChain::DrawType kType = GrPathRendererChain::DrawType::kColor;
+ if (originalShape.isEmpty() && !originalShape.inverseFilled()) {
+ return;
+ }
+
+ canDrawArgs.fAAType = aaType;
+
+ // Try a 1st time without applying any of the style to the geometry (and barring sw)
+ pr = this->drawingManager()->getPathRenderer(canDrawArgs, false, kType);
+ SkScalar styleScale = GrStyle::MatrixToScaleFactor(viewMatrix);
+
+ if (!pr && originalShape.style().pathEffect()) {
+ // It didn't work above, so try again with the path effect applied.
+ tempShape = originalShape.applyStyle(GrStyle::Apply::kPathEffectOnly, styleScale);
+ if (tempShape.isEmpty()) {
+ return;
+ }
+ canDrawArgs.fShape = &tempShape;
+ pr = this->drawingManager()->getPathRenderer(canDrawArgs, false, kType);
+ }
+ if (!pr) {
+ if (canDrawArgs.fShape->style().applies()) {
+ tempShape = canDrawArgs.fShape->applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec,
+ styleScale);
+ if (tempShape.isEmpty()) {
+ return;
+ }
+ canDrawArgs.fShape = &tempShape;
+ // This time, allow SW renderer
+ pr = this->drawingManager()->getPathRenderer(canDrawArgs, true, kType);
+ } else {
+ pr = this->drawingManager()->getSoftwarePathRenderer();
+#if GR_PATH_RENDERER_SPEW
+ SkDebugf("falling back to: %s\n", pr->name());
+#endif
+ }
+ }
+
+ if (!pr) {
+#ifdef SK_DEBUG
+ SkDebugf("Unable to find path renderer compatible with path.\n");
+#endif
+ return;
+ }
+
+ GrPathRenderer::DrawPathArgs args{this->drawingManager()->getContext(),
+ std::move(paint),
+ &GrUserStencilSettings::kUnused,
+ this,
+ clip,
+ &clipConservativeBounds,
+ &viewMatrix,
+ canDrawArgs.fShape,
+ aaType,
+ this->colorInfo().isLinearlyBlended()};
+ pr->drawPath(args);
+}
+
+static void op_bounds(SkRect* bounds, const GrOp* op) {
+ *bounds = op->bounds();
+ if (op->hasZeroArea()) {
+ if (op->hasAABloat()) {
+ bounds->outset(0.5f, 0.5f);
+ } else {
+ // We don't know which way the particular GPU will snap lines or points at integer
+ // coords. So we ensure that the bounds is large enough for either snap.
+ SkRect before = *bounds;
+ bounds->roundOut(bounds);
+ if (bounds->fLeft == before.fLeft) {
+ bounds->fLeft -= 1;
+ }
+ if (bounds->fTop == before.fTop) {
+ bounds->fTop -= 1;
+ }
+ if (bounds->fRight == before.fRight) {
+ bounds->fRight += 1;
+ }
+ if (bounds->fBottom == before.fBottom) {
+ bounds->fBottom += 1;
+ }
+ }
+ }
+}
+
+void GrSurfaceDrawContext::addOp(GrOp::Owner op) {
+ GrDrawingManager* drawingMgr = this->drawingManager();
+ this->getOpsTask()->addOp(drawingMgr,
+ std::move(op), GrTextureResolveManager(drawingMgr), *this->caps());
+}
+
+void GrSurfaceDrawContext::addDrawOp(const GrClip* clip,
+ GrOp::Owner op,
+ const std::function<WillAddOpFn>& willAddFn) {
+ ASSERT_SINGLE_OWNER
+ if (fContext->abandoned()) {
+ return;
+ }
+ GrDrawOp* drawOp = (GrDrawOp*)op.get();
+ SkDEBUGCODE(this->validate();)
+ SkDEBUGCODE(drawOp->fAddDrawOpCalled = true;)
+ GR_CREATE_TRACE_MARKER_CONTEXT("GrSurfaceDrawContext", "addDrawOp", fContext);
+
+ // Setup clip
+ SkRect bounds;
+ op_bounds(&bounds, op.get());
+ GrAppliedClip appliedClip(this->dimensions(), this->asSurfaceProxy()->backingStoreDimensions());
+ GrDrawOp::FixedFunctionFlags fixedFunctionFlags = drawOp->fixedFunctionFlags();
+ bool usesHWAA = fixedFunctionFlags & GrDrawOp::FixedFunctionFlags::kUsesHWAA;
+ bool usesUserStencilBits = fixedFunctionFlags & GrDrawOp::FixedFunctionFlags::kUsesStencil;
+
+ if (usesUserStencilBits) { // Stencil clipping will call setNeedsStencil on its own, if needed.
+ this->setNeedsStencil(usesHWAA);
+ }
+
+ bool skipDraw = false;
+ if (clip) {
+ // Have a complex clip, so defer to its early clip culling
+ GrAAType aaType = usesHWAA ? GrAAType::kMSAA :
+ (op->hasAABloat() ? GrAAType::kCoverage :
+ GrAAType::kNone);
+ skipDraw = clip->apply(fContext, this, aaType, usesUserStencilBits,
+ &appliedClip, &bounds) == GrClip::Effect::kClippedOut;
+ } else {
+ // No clipping, so just clip the bounds against the logical render target dimensions
+ skipDraw = !bounds.intersect(this->asSurfaceProxy()->getBoundsRect());
+ }
+
+ if (skipDraw) {
+ return;
+ }
+
+ bool willUseStencil = usesUserStencilBits || appliedClip.hasStencilClip();
+ SkASSERT(!willUseStencil || fNumStencilSamples > 0);
+
+ // If stencil is enabled and the framebuffer is mixed sampled, then the graphics pipeline will
+ // have mixed sampled coverage, regardless of whether HWAA is enabled. (e.g., a non-aa draw
+ // that uses a stencil test when the stencil buffer is multisampled.)
+ bool hasMixedSampledCoverage = (
+ willUseStencil && fNumStencilSamples > this->numSamples());
+ SkASSERT(!hasMixedSampledCoverage ||
+ this->asRenderTargetProxy()->canUseMixedSamples(*this->caps()));
+
+ GrClampType clampType = GrColorTypeClampType(this->colorInfo().colorType());
+ GrProcessorSet::Analysis analysis = drawOp->finalize(
+ *this->caps(), &appliedClip, hasMixedSampledCoverage, clampType);
+
+ // Must be called before setDstProxyView so that it sees the final bounds of the op.
+ op->setClippedBounds(bounds);
+
+ GrXferProcessor::DstProxyView dstProxyView;
+ if (analysis.requiresDstTexture()) {
+ if (!this->setupDstProxyView(*op, &dstProxyView)) {
+ return;
+ }
+ }
+
+ auto opsTask = this->getOpsTask();
+ if (willAddFn) {
+ willAddFn(op.get(), opsTask->uniqueID());
+ }
+ opsTask->addDrawOp(this->drawingManager(), std::move(op), analysis, std::move(appliedClip),
+ dstProxyView, GrTextureResolveManager(this->drawingManager()),
+ *this->caps());
+}
+
+bool GrSurfaceDrawContext::setupDstProxyView(const GrOp& op,
+ GrXferProcessor::DstProxyView* dstProxyView) {
+ // If we are wrapping a vulkan secondary command buffer, we can't make a dst copy because we
+ // don't actually have a VkImage to make a copy of. Additionally we don't have the power to
+ // start and stop the render pass in order to make the copy.
+ if (this->asRenderTargetProxy()->wrapsVkSecondaryCB()) {
+ return false;
+ }
+
+ if (fDstSampleType == GrDstSampleType::kNone) {
+ fDstSampleType = this->caps()->getDstSampleTypeForProxy(this->asRenderTargetProxy());
+ }
+ SkASSERT(fDstSampleType != GrDstSampleType::kNone);
+
+ if (GrDstSampleTypeDirectlySamplesDst(fDstSampleType)) {
+ // The render target is a texture or input attachment, so we can read from it directly in
+ // the shader. The XP will be responsible to detect this situation and request a texture
+ // barrier.
+ dstProxyView->setProxyView(this->readSurfaceView());
+ dstProxyView->setOffset(0, 0);
+ dstProxyView->setDstSampleType(fDstSampleType);
+ return true;
+ }
+ SkASSERT(fDstSampleType == GrDstSampleType::kAsTextureCopy);
+
+ GrColorType colorType = this->colorInfo().colorType();
+ // MSAA consideration: When there is support for reading MSAA samples in the shader we could
+ // have per-sample dst values by making the copy multisampled.
+ GrCaps::DstCopyRestrictions restrictions = this->caps()->getDstCopyRestrictions(
+ this->asRenderTargetProxy(), colorType);
+
+ SkIRect copyRect = SkIRect::MakeSize(this->asSurfaceProxy()->backingStoreDimensions());
+ if (!restrictions.fMustCopyWholeSrc) {
+ // If we don't need the whole source, restrict to the op's bounds. We add an extra pixel
+ // of padding to account for AA bloat and the unpredictable rounding of coords near pixel
+ // centers during rasterization.
+ SkIRect conservativeDrawBounds = op.bounds().roundOut();
+ conservativeDrawBounds.outset(1, 1);
+ SkAssertResult(copyRect.intersect(conservativeDrawBounds));
+ }
+
+ SkIPoint dstOffset;
+ SkBackingFit fit;
+ if (restrictions.fRectsMustMatch == GrSurfaceProxy::RectsMustMatch::kYes) {
+ dstOffset = {0, 0};
+ fit = SkBackingFit::kExact;
+ } else {
+ dstOffset = {copyRect.fLeft, copyRect.fTop};
+ fit = SkBackingFit::kApprox;
+ }
+ auto copy =
+ GrSurfaceProxy::Copy(fContext, this->asSurfaceProxy(), this->origin(), GrMipmapped::kNo,
+ copyRect, fit, SkBudgeted::kYes, restrictions.fRectsMustMatch);
+ SkASSERT(copy);
+
+ dstProxyView->setProxyView({std::move(copy), this->origin(), this->readSwizzle()});
+ dstProxyView->setOffset(dstOffset);
+ dstProxyView->setDstSampleType(fDstSampleType);
+ return true;
+}
+
+bool GrSurfaceDrawContext::blitTexture(GrSurfaceProxyView view,
+ const SkIRect& srcRect,
+ const SkIPoint& dstPoint) {
+ SkASSERT(view.asTextureProxy());
+ SkIRect clippedSrcRect;
+ SkIPoint clippedDstPoint;
+ if (!GrClipSrcRectAndDstPoint(this->asSurfaceProxy()->dimensions(), view.proxy()->dimensions(),
+ srcRect, dstPoint, &clippedSrcRect, &clippedDstPoint)) {
+ return false;
+ }
+
+ GrPaint paint;
+ paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
+
+ auto fp = GrTextureEffect::Make(std::move(view), kUnknown_SkAlphaType);
+ if (!fp) {
+ return false;
+ }
+ paint.setColorFragmentProcessor(std::move(fp));
+
+ this->fillRectToRect(
+ nullptr, std::move(paint), GrAA::kNo, SkMatrix::I(),
+ SkRect::MakeXYWH(clippedDstPoint.fX, clippedDstPoint.fY, clippedSrcRect.width(),
+ clippedSrcRect.height()),
+ SkRect::Make(clippedSrcRect));
+ return true;
+}