Revert "Add general quad API to SkGpuDevice"
This reverts commit 339e1cc8d4574a5498d9bf13bbbc91377c8b0846.
Reason for revert: compositor GM breaks dm on windows
Original change's description:
> Add general quad API to SkGpuDevice
>
> Heavily refactors SkGpuDevice's internal texturing code in an attempt
> to consolidate entry points for drawing an image. Helps lay the ground
> work for eventually implementing bitmap tiling with per-edge AA.
>
> Bug: skia:
> Change-Id: I9feb86d5315d73119deb21e954c45e45513a63f6
> Reviewed-on: https://skia-review.googlesource.com/c/191571
> Commit-Queue: Michael Ludwig <michaelludwig@google.com>
> Reviewed-by: Brian Salomon <bsalomon@google.com>
TBR=bsalomon@google.com,robertphillips@google.com,michaelludwig@google.com
Change-Id: I74bc7eb08855dff5535cf809fc47ce6f16d2c15d
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/c/195889
Reviewed-by: Michael Ludwig <michaelludwig@google.com>
Commit-Queue: Michael Ludwig <michaelludwig@google.com>
diff --git a/src/gpu/SkGpuDevice_drawTexture.cpp b/src/gpu/SkGpuDevice_drawTexture.cpp
index da2c887..21815f7 100644
--- a/src/gpu/SkGpuDevice_drawTexture.cpp
+++ b/src/gpu/SkGpuDevice_drawTexture.cpp
@@ -6,12 +6,9 @@
*/
#include "SkGpuDevice.h"
-
-#include "GrBitmapTextureMaker.h"
#include "GrBlurUtils.h"
#include "GrCaps.h"
#include "GrColorSpaceXform.h"
-#include "GrImageTextureMaker.h"
#include "GrRenderTargetContext.h"
#include "GrShape.h"
#include "GrStyle.h"
@@ -19,15 +16,11 @@
#include "GrTextureMaker.h"
#include "SkDraw.h"
#include "SkGr.h"
-#include "SkImage_Base.h"
#include "SkMaskFilterBase.h"
-#include "SkYUVAIndex.h"
#include "effects/GrBicubicEffect.h"
#include "effects/GrSimpleTextureEffect.h"
#include "effects/GrTextureDomain.h"
-namespace {
-
static inline bool use_shader(bool textureIsAlphaOnly, const SkPaint& paint) {
return textureIsAlphaOnly && paint.getShader();
}
@@ -94,73 +87,6 @@
return false;
}
-enum class ImageDrawMode {
- // Src and dst have been restricted to the image content. May need to clamp, no need to decal.
- kOptimized,
- // Src and dst are their original sizes, requires use of a decal instead of plain clamping.
- // This is used when a dst clip is provided and extends outside of the optimized dst rect.
- kDecal,
- // Src or dst are empty, or do not intersect the image content so don't draw anything.
- kSkip
-};
-
-/**
- * Optimize the src rect sampling area within an image (sized 'width' x 'height') such that
- * 'outSrcRect' will be completely contained in the image's bounds. The corresponding rect
- * to draw will be output to 'outDstRect'. The mapping between src and dst will be cached in
- * 'srcToDst'. Outputs are not always updated when kSkip is returned.
- *
- * If 'origSrcRect' is null, implicitly use the image bounds. If 'origDstRect' is null, use the
- * original src rect. 'dstClip' should be null when there is no additional clipping.
- */
-static ImageDrawMode optimize_sample_area(const SkISize& image, const SkRect* origSrcRect,
- const SkRect* origDstRect, const SkPoint dstClip[4],
- SkRect* outSrcRect, SkRect* outDstRect,
- SkMatrix* srcToDst) {
- SkRect srcBounds = SkRect::MakeIWH(image.fWidth, image.fHeight);
-
- SkRect src = origSrcRect ? *origSrcRect : srcBounds;
- SkRect dst = origDstRect ? *origDstRect : src;
-
- if (src.isEmpty() || dst.isEmpty()) {
- return ImageDrawMode::kSkip;
- }
-
- if (outDstRect) {
- srcToDst->setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
- } else {
- srcToDst->setIdentity();
- }
-
- if (origSrcRect && !srcBounds.contains(src)) {
- if (!src.intersect(srcBounds)) {
- return ImageDrawMode::kSkip;
- }
- srcToDst->mapRect(&dst, src);
-
- // Both src and dst have gotten smaller. If dstClip is provided, confirm it is still
- // contained in dst, otherwise cannot optimize the sample area and must use a decal instead
- if (dstClip) {
- for (int i = 0; i < 4; ++i) {
- if (!dst.contains(dstClip[i].fX, dstClip[i].fY)) {
- // Must resort to using a decal mode restricted to the clipped 'src', and
- // use the original dst rect (filling in src bounds as needed)
- *outSrcRect = src;
- *outDstRect = (origDstRect ? *origDstRect
- : (origSrcRect ? *origSrcRect : srcBounds));
- return ImageDrawMode::kDecal;
- }
- }
- }
- }
-
- // The original src and dst were fully contained in the image, or there was no dst clip to
- // worry about, or the clip was still contained in the restricted dst rect.
- *outSrcRect = src;
- *outDstRect = dst;
- return ImageDrawMode::kOptimized;
-}
-
/**
* Checks whether the paint is compatible with using GrRenderTargetContext::drawTexture. It is more
* efficient than the GrTextureProducer general case.
@@ -170,12 +96,20 @@
!paint.getImageFilter() && paint.getFilterQuality() < kMedium_SkFilterQuality);
}
-// Assumes srcRect and dstRect have already been optimized to fit the proxy
-static void draw_texture(GrRenderTargetContext* rtc, const GrClip& clip, const SkMatrix& ctm,
- const SkPaint& paint, const SkRect& srcRect, const SkRect& dstRect,
- const SkPoint dstClip[4], GrAA aa, GrQuadAAFlags aaFlags,
- SkCanvas::SrcRectConstraint constraint, sk_sp<GrTextureProxy> proxy,
- SkAlphaType alphaType, SkColorSpace* colorSpace) {
+static void draw_texture(const SkPaint& paint, const SkMatrix& ctm, const SkRect* src,
+ const SkRect* dst, GrAA aa, SkCanvas::SrcRectConstraint constraint,
+ sk_sp<GrTextureProxy> proxy, SkAlphaType alphaType,
+ SkColorSpace* colorSpace, const GrClip& clip, GrRenderTargetContext* rtc) {
+ SkASSERT(!(SkToBool(src) && !SkToBool(dst)));
+ SkRect srcRect = src ? *src : SkRect::MakeWH(proxy->width(), proxy->height());
+ SkRect dstRect = dst ? *dst : srcRect;
+ if (src && !SkRect::MakeIWH(proxy->width(), proxy->height()).contains(srcRect)) {
+ // Shrink the src rect to be within bounds and proportionately shrink the dst rect.
+ SkMatrix srcToDst;
+ srcToDst.setRectToRect(srcRect, dstRect, SkMatrix::kFill_ScaleToFit);
+ SkAssertResult(srcRect.intersect(SkRect::MakeIWH(proxy->width(), proxy->height())));
+ srcToDst.mapRect(&dstRect, srcRect);
+ }
const GrColorSpaceInfo& dstInfo(rtc->colorSpaceInfo());
auto textureXform =
GrColorSpaceXform::Make(colorSpace , alphaType,
@@ -214,42 +148,107 @@
float paintAlpha = paint.getColor4f().fA;
color = { paintAlpha, paintAlpha, paintAlpha, paintAlpha };
}
-
- if (dstClip) {
- // Get source coords corresponding to dstClip
- SkPoint srcQuad[4];
- GrMapRectPoints(dstRect, srcRect, dstClip, srcQuad, 4);
-
- rtc->drawTextureQuad(clip, std::move(proxy), filter, paint.getBlendMode(), color,
- srcQuad, dstClip, aa, aaFlags,
- constraint == SkCanvas::kStrict_SrcRectConstraint ? &srcRect : nullptr,
- ctm, std::move(textureXform));
- } else {
- rtc->drawTexture(clip, std::move(proxy), filter, paint.getBlendMode(), color, srcRect,
- dstRect, aa, aaFlags, constraint, ctm, std::move(textureXform));
- }
+ GrQuadAAFlags aaFlags = aa == GrAA::kYes ? GrQuadAAFlags::kAll : GrQuadAAFlags::kNone;
+ rtc->drawTexture(clip, std::move(proxy), filter, paint.getBlendMode(), color, srcRect, dstRect,
+ aa, aaFlags, constraint, ctm, std::move(textureXform));
}
-// Assumes srcRect and dstRect have already been optimized to fit the proxy.
-static void draw_texture_producer(GrContext* context, GrRenderTargetContext* rtc,
- const GrClip& clip, const SkMatrix& ctm,
- const SkPaint& paint, GrTextureProducer* producer,
- const SkRect& src, const SkRect& dst, const SkPoint dstClip[4],
- const SkMatrix& srcToDst, GrAA aa, GrQuadAAFlags aaFlags,
- SkCanvas::SrcRectConstraint constraint, bool attemptDrawTexture) {
+//////////////////////////////////////////////////////////////////////////////
+
+void SkGpuDevice::drawPinnedTextureProxy(sk_sp<GrTextureProxy> proxy, uint32_t pinnedUniqueID,
+ SkColorSpace* colorSpace, SkAlphaType alphaType,
+ const SkRect* srcRect, const SkRect* dstRect,
+ SkCanvas::SrcRectConstraint constraint,
+ const SkMatrix& viewMatrix, const SkPaint& paint) {
+ GrAA aa = GrAA(paint.isAntiAlias());
+ if (can_use_draw_texture(paint)) {
+ draw_texture(paint, viewMatrix, srcRect, dstRect, aa, constraint, std::move(proxy),
+ alphaType, colorSpace, this->clip(), fRenderTargetContext.get());
+ return;
+ }
+ GrTextureAdjuster adjuster(this->context(), std::move(proxy), alphaType, pinnedUniqueID,
+ colorSpace);
+ this->drawTextureProducer(&adjuster, srcRect, dstRect, constraint, viewMatrix, paint, false);
+}
+
+void SkGpuDevice::drawTextureProducer(GrTextureProducer* producer,
+ const SkRect* srcRect,
+ const SkRect* dstRect,
+ SkCanvas::SrcRectConstraint constraint,
+ const SkMatrix& viewMatrix,
+ const SkPaint& paint,
+ bool attemptDrawTexture) {
if (attemptDrawTexture && can_use_draw_texture(paint)) {
+ GrAA aa = GrAA(paint.isAntiAlias());
// We've done enough checks above to allow us to pass ClampNearest() and not check for
// scaling adjustments.
auto proxy = producer->refTextureProxyForParams(GrSamplerState::ClampNearest(), nullptr);
if (!proxy) {
return;
}
-
- draw_texture(rtc, clip, ctm, paint, src, dst, dstClip, aa, aaFlags, constraint,
- std::move(proxy), producer->alphaType(), producer->colorSpace());
+ draw_texture(paint, viewMatrix, srcRect, dstRect, aa, constraint, std::move(proxy),
+ producer->alphaType(), producer->colorSpace(), this->clip(),
+ fRenderTargetContext.get());
return;
}
+ // This is the funnel for all non-tiled bitmap/image draw calls. Log a histogram entry.
+ SK_HISTOGRAM_BOOLEAN("DrawTiled", false);
+
+ // Figure out the actual dst and src rect by clipping the src rect to the bounds of the
+ // adjuster. If the src rect is clipped then the dst rect must be recomputed. Also determine
+ // the matrix that maps the src rect to the dst rect.
+ SkRect clippedSrcRect;
+ SkRect clippedDstRect;
+ const SkRect srcBounds = SkRect::MakeIWH(producer->width(), producer->height());
+ SkMatrix srcToDstMatrix;
+ if (srcRect) {
+ if (!dstRect) {
+ dstRect = &srcBounds;
+ }
+ if (!srcBounds.contains(*srcRect)) {
+ clippedSrcRect = *srcRect;
+ if (!clippedSrcRect.intersect(srcBounds)) {
+ return;
+ }
+ if (!srcToDstMatrix.setRectToRect(*srcRect, *dstRect, SkMatrix::kFill_ScaleToFit)) {
+ return;
+ }
+ srcToDstMatrix.mapRect(&clippedDstRect, clippedSrcRect);
+ } else {
+ clippedSrcRect = *srcRect;
+ clippedDstRect = *dstRect;
+ if (!srcToDstMatrix.setRectToRect(*srcRect, *dstRect, SkMatrix::kFill_ScaleToFit)) {
+ return;
+ }
+ }
+ } else {
+ clippedSrcRect = srcBounds;
+ if (dstRect) {
+ clippedDstRect = *dstRect;
+ if (!srcToDstMatrix.setRectToRect(srcBounds, *dstRect, SkMatrix::kFill_ScaleToFit)) {
+ return;
+ }
+ } else {
+ clippedDstRect = srcBounds;
+ srcToDstMatrix.reset();
+ }
+ }
+
+ // Now that we have both the view and srcToDst matrices, log our scale factor.
+ LogDrawScaleFactor(viewMatrix, srcToDstMatrix, paint.getFilterQuality());
+
+ this->drawTextureProducerImpl(producer, clippedSrcRect, clippedDstRect, constraint, viewMatrix,
+ srcToDstMatrix, paint);
+}
+
+void SkGpuDevice::drawTextureProducerImpl(GrTextureProducer* producer,
+ const SkRect& clippedSrcRect,
+ const SkRect& clippedDstRect,
+ SkCanvas::SrcRectConstraint constraint,
+ const SkMatrix& viewMatrix,
+ const SkMatrix& srcToDstMatrix,
+ const SkPaint& paint) {
const SkMaskFilter* mf = paint.getMaskFilter();
// The shader expects proper local coords, so we can't replace local coords with texture coords
@@ -258,16 +257,17 @@
bool canUseTextureCoordsAsLocalCoords = !use_shader(producer->isAlphaOnly(), paint) && !mf;
// Specifying the texture coords as local coordinates is an attempt to enable more GrDrawOp
- // combining by not baking anything about the srcRect, dstRect, or ctm, into the texture
+ // combining by not baking anything about the srcRect, dstRect, or viewMatrix, into the texture
// FP. In the future this should be an opaque optimization enabled by the combination of
// GrDrawOp/GP and FP.
if (mf && as_MFB(mf)->hasFragmentProcessor()) {
mf = nullptr;
}
+
bool doBicubic;
GrSamplerState::Filter fm = GrSkFilterQualityToGrFilterMode(
- paint.getFilterQuality(), ctm, srcToDst,
- context->priv().options().fSharpenMipmappedTextures, &doBicubic);
+ paint.getFilterQuality(), viewMatrix, srcToDstMatrix,
+ fContext->priv().options().fSharpenMipmappedTextures, &doBicubic);
const GrSamplerState::Filter* filterMode = doBicubic ? nullptr : &fm;
GrTextureProducer::FilterConstraint constraintMode;
@@ -280,302 +280,58 @@
// If we have to outset for AA then we will generate texture coords outside the src rect. The
// same happens for any mask filter that extends the bounds rendered in the dst.
// This is conservative as a mask filter does not have to expand the bounds rendered.
- bool coordsAllInsideSrcRect = aaFlags == GrQuadAAFlags::kNone && !mf;
+ bool coordsAllInsideSrcRect = !paint.isAntiAlias() && !mf;
// Check for optimization to drop the src rect constraint when on bilerp.
if (filterMode && GrSamplerState::Filter::kBilerp == *filterMode &&
GrTextureAdjuster::kYes_FilterConstraint == constraintMode && coordsAllInsideSrcRect) {
SkMatrix combinedMatrix;
- combinedMatrix.setConcat(ctm, srcToDst);
- if (can_ignore_bilerp_constraint(*producer, src, combinedMatrix, rtc->fsaaType())) {
+ combinedMatrix.setConcat(viewMatrix, srcToDstMatrix);
+ if (can_ignore_bilerp_constraint(*producer, clippedSrcRect, combinedMatrix,
+ fRenderTargetContext->fsaaType())) {
constraintMode = GrTextureAdjuster::kNo_FilterConstraint;
}
}
- SkMatrix textureMatrix;
+ const SkMatrix* textureMatrix;
+ SkMatrix tempMatrix;
if (canUseTextureCoordsAsLocalCoords) {
- textureMatrix = SkMatrix::I();
+ textureMatrix = &SkMatrix::I();
} else {
- if (!srcToDst.invert(&textureMatrix)) {
+ if (!srcToDstMatrix.invert(&tempMatrix)) {
return;
}
+ textureMatrix = &tempMatrix;
}
- auto fp = producer->createFragmentProcessor(textureMatrix, src, constraintMode,
+ auto fp = producer->createFragmentProcessor(*textureMatrix, clippedSrcRect, constraintMode,
coordsAllInsideSrcRect, filterMode);
fp = GrColorSpaceXformEffect::Make(std::move(fp), producer->colorSpace(), producer->alphaType(),
- rtc->colorSpaceInfo().colorSpace());
+ fRenderTargetContext->colorSpaceInfo().colorSpace());
if (!fp) {
return;
}
GrPaint grPaint;
- if (!SkPaintToGrPaintWithTexture(context, rtc->colorSpaceInfo(), paint, ctm,
- std::move(fp), producer->isAlphaOnly(), &grPaint)) {
+ if (!SkPaintToGrPaintWithTexture(fContext.get(), fRenderTargetContext->colorSpaceInfo(), paint,
+ viewMatrix, std::move(fp), producer->isAlphaOnly(),
+ &grPaint)) {
+ return;
+ }
+ GrAA aa = GrAA(paint.isAntiAlias());
+ if (canUseTextureCoordsAsLocalCoords) {
+ fRenderTargetContext->fillRectToRect(this->clip(), std::move(grPaint), aa, viewMatrix,
+ clippedDstRect, clippedSrcRect);
return;
}
if (!mf) {
- // Can draw the image directly (any mask filter on the paint was converted to an FP already)
- if (dstClip) {
- SkPoint srcClipPoints[4];
- SkPoint* srcClip = nullptr;
- if (canUseTextureCoordsAsLocalCoords) {
- // Calculate texture coordinates that match the dst clip
- GrMapRectPoints(dst, src, dstClip, srcClipPoints, 4);
- srcClip = srcClipPoints;
- }
- rtc->fillQuadWithEdgeAA(clip, std::move(grPaint), aa, aaFlags, ctm, dstClip, srcClip);
- } else {
- // Provide explicit texture coords when possible, otherwise rely on texture matrix
- rtc->fillRectWithEdgeAA(clip, std::move(grPaint), aa, aaFlags, ctm, dst,
- canUseTextureCoordsAsLocalCoords ? &src : nullptr);
- }
- } else {
- // Must draw the mask filter as a GrShape. For now, this loses the per-edge AA information
- // since it always draws with AA, but that is should not be noticeable since the mask filter
- // is probably a blur.
- GrShape shape;
- if (dstClip) {
- // Represent it as an SkPath formed from the dstClip
- SkPath path;
- path.addPoly(dstClip, 4, true);
- shape = GrShape(path);
- } else {
- shape = GrShape(dst);
- }
-
- GrBlurUtils::drawShapeWithMaskFilter(
- context, rtc, clip, shape, std::move(grPaint), ctm, mf);
- }
-}
-
-} // anonymous namespace
-
-//////////////////////////////////////////////////////////////////////////////
-
-void SkGpuDevice::drawImageQuad(const SkImage* image, const SkRect* srcRect, const SkRect* dstRect,
- const SkPoint dstClip[4], GrAA aa, GrQuadAAFlags aaFlags,
- const SkPaint& paint, SkCanvas::SrcRectConstraint constraint) {
- SkRect src;
- SkRect dst;
- SkMatrix srcToDst;
- ImageDrawMode mode = optimize_sample_area(SkISize::Make(image->width(), image->height()),
- srcRect, dstRect, dstClip, &src, &dst, &srcToDst);
- if (mode == ImageDrawMode::kSkip) {
+ fRenderTargetContext->drawRect(this->clip(), std::move(grPaint), aa, viewMatrix,
+ clippedDstRect);
return;
}
- if (src.contains(image->bounds())) {
- constraint = SkCanvas::kFast_SrcRectConstraint;
- }
- // Depending on the nature of image, it can flow through more or less optimal pipelines
- bool useDecal = mode == ImageDrawMode::kDecal;
- bool attemptDrawTexture = !useDecal; // rtc->drawTexture() only clamps
+ GrShape shape(clippedDstRect, GrStyle::SimpleFill());
- // YUVA images can be stored in multiple images with different plane resolutions, so this
- // uses an effect to combine them dynamically on the GPU. This is done before requesting a
- // pinned texture proxy because YUV images force-flatten to RGBA in that scenario.
- if (as_IB(image)->isYUVA()) {
- SK_HISTOGRAM_BOOLEAN("DrawTiled", false);
- LogDrawScaleFactor(this->ctm(), srcToDst, paint.getFilterQuality());
-
- GrYUVAImageTextureMaker maker(fContext.get(), image, useDecal);
- draw_texture_producer(fContext.get(), fRenderTargetContext.get(), this->clip(), this->ctm(),
- paint, &maker, src, dst, dstClip, srcToDst, aa, aaFlags, constraint,
- /* attempt draw texture */ false);
- return;
- }
-
- // Pinned texture proxies can be rendered directly as textures, or with relatively simple
- // adjustments applied to the image content (scaling, mipmaps, color space, etc.)
- uint32_t pinnedUniqueID;
- if (sk_sp<GrTextureProxy> proxy = as_IB(image)->refPinnedTextureProxy(&pinnedUniqueID)) {
- SK_HISTOGRAM_BOOLEAN("DrawTiled", false);
- LogDrawScaleFactor(this->ctm(), srcToDst, paint.getFilterQuality());
-
- SkAlphaType alphaType = image->alphaType();
- SkColorSpace* colorSpace = as_IB(image)->colorSpace();
-
- if (attemptDrawTexture && can_use_draw_texture(paint)) {
- draw_texture(fRenderTargetContext.get(), this->clip(), this->ctm(), paint, src, dst,
- dstClip, aa, aaFlags, constraint, std::move(proxy), alphaType, colorSpace);
- return;
- }
-
- GrTextureAdjuster adjuster(fContext.get(), std::move(proxy), alphaType, pinnedUniqueID,
- colorSpace, useDecal);
- draw_texture_producer(fContext.get(), fRenderTargetContext.get(), this->clip(), this->ctm(),
- paint, &adjuster, src, dst, dstClip, srcToDst, aa, aaFlags,
- constraint, /* attempt draw_texture */ false);
- return;
- }
-
- // Next up, try tiling the image
- // TODO (michaelludwig): Implement this with per-edge AA flags to handle seaming properly
- // instead of going through drawBitmapRect (which will be removed from SkDevice in the future)
- SkBitmap bm;
- if (this->shouldTileImage(image, &src, constraint, paint.getFilterQuality(), this->ctm(),
- srcToDst)) {
- // only support tiling as bitmap at the moment, so force raster-version
- if (!as_IB(image)->getROPixels(&bm)) {
- return;
- }
- this->drawBitmapRect(bm, &src, dst, paint, constraint);
- return;
- }
-
- // This is the funnel for all non-tiled bitmap/image draw calls. Log a histogram entry.
- SK_HISTOGRAM_BOOLEAN("DrawTiled", false);
- LogDrawScaleFactor(this->ctm(), srcToDst, paint.getFilterQuality());
-
- // Lazily generated images must get drawn as a texture producer that handles the final
- // texture creation.
- if (image->isLazyGenerated()) {
- GrImageTextureMaker maker(fContext.get(), image, SkImage::kAllow_CachingHint, useDecal);
- draw_texture_producer(fContext.get(), fRenderTargetContext.get(), this->clip(), this->ctm(),
- paint, &maker, src, dst, dstClip, srcToDst, aa, aaFlags, constraint,
- attemptDrawTexture);
- return;
- }
- if (as_IB(image)->getROPixels(&bm)) {
- GrBitmapTextureMaker maker(fContext.get(), bm, useDecal);
- draw_texture_producer(fContext.get(), fRenderTargetContext.get(), this->clip(), this->ctm(),
- paint, &maker, src, dst, dstClip, srcToDst, aa, aaFlags, constraint,
- attemptDrawTexture);
- }
-
- // Otherwise don't know how to draw it
-}
-
-// For ease-of-use, the temporary API treats null dstClipCounts as if it were the proper sized
-// array, filled with all 0s (so dstClips can be null too)
-void SkGpuDevice::tmp_drawImageSetV2(const SkCanvas::ImageSetEntry set[], int dstClipCounts[],
- int count, const SkPoint dstClips[], const SkPaint& paint,
- SkCanvas::SrcRectConstraint constraint) {
- SkASSERT(count > 0);
-
- if (!can_use_draw_texture(paint)) {
- // Send every entry through drawImageQuad() to handle the more complicated paint
- int dstClipIndex = 0;
- for (int i = 0; i < count; ++i) {
- // Only no clip or quad clip are supported
- SkASSERT(!dstClipCounts || dstClipCounts[i] == 0 || dstClipCounts[i] == 4);
- // Always send GrAA::kYes to preserve seaming across tiling in MSAA
- this->drawImageQuad(set[i].fImage.get(), &set[i].fSrcRect, &set[i].fDstRect,
- (dstClipCounts && dstClipCounts[i] > 0) ? dstClips + dstClipIndex : nullptr,
- GrAA::kYes, SkToGrQuadAAFlags(set[i].fAAFlags), paint, constraint);
- if (dstClipCounts) {
- dstClipIndex += dstClipCounts[i];
- }
- }
- return;
- }
-
- GrSamplerState::Filter filter = kNone_SkFilterQuality == paint.getFilterQuality() ?
- GrSamplerState::Filter::kNearest : GrSamplerState::Filter::kBilerp;
- SkBlendMode mode = paint.getBlendMode();
-
- SkAutoTArray<GrRenderTargetContext::TextureSetEntry> textures(count);
- // We accumulate compatible proxies until we find an an incompatible one or reach the end and
- // issue the accumulated 'n' draws starting at 'base'.
- int base = 0, n = 0;
- auto draw = [&] {
- if (n > 0) {
- auto textureXform = GrColorSpaceXform::Make(
- set[base].fImage->colorSpace(), set[base].fImage->alphaType(),
- fRenderTargetContext->colorSpaceInfo().colorSpace(), kPremul_SkAlphaType);
- fRenderTargetContext->drawTextureSet(this->clip(), textures.get() + base, n,
- filter, mode, GrAA::kYes, this->ctm(),
- std::move(textureXform));
- }
- };
- int dstClipIndex = 0;
- for (int i = 0; i < count; ++i) {
- // Manage the dst clip pointer tracking before any continues are used so we don't lose
- // our place in the dstClips array.
- int clipCount = (dstClipCounts ? dstClipCounts[i] : 0);
- SkASSERT(clipCount == 0 || (dstClipCounts[i] == 4 && dstClips));
- const SkPoint* clip = clipCount > 0 ? dstClips + dstClipIndex : nullptr;
- if (dstClipCounts) {
- dstClipIndex += dstClipCounts[i];
- }
- // The default SkBaseDevice implementation is based on drawImageRect which does not allow
- // non-sorted src rects. TODO: Decide this is OK or make sure we handle it.
- if (!set[i].fSrcRect.isSorted()) {
- draw();
- base = i + 1;
- n = 0;
- continue;
- }
-
- uint32_t uniqueID;
- textures[i].fProxy = as_IB(set[i].fImage.get())->refPinnedTextureProxy(&uniqueID);
- if (!textures[i].fProxy) {
- // FIXME(michaelludwig) - If asTextureProxyRef fails, does going through drawImageQuad
- // make sense? Does that catch the lazy-image cases then?
- // FIXME(michaelludwig) - Both refPinnedTextureProxy and asTextureProxyRef for YUVA
- // images force flatten the planes. It would be nice to detect a YUVA image entry and
- // send it to drawImageQuad (which uses a special effect for YUV)
- textures[i].fProxy =
- as_IB(set[i].fImage.get())
- ->asTextureProxyRef(fContext.get(), GrSamplerState::ClampBilerp(),
- nullptr);
- // If we failed to make a proxy then flush the accumulated set and reset for the next
- // image.
- if (!textures[i].fProxy) {
- draw();
- base = i + 1;
- n = 0;
- continue;
- }
- }
- textures[i].fSrcRect = set[i].fSrcRect;
- textures[i].fDstRect = set[i].fDstRect;
- textures[i].fDstClipQuad = clip;
- textures[i].fAlpha = set[i].fAlpha * paint.getAlphaf();
- textures[i].fAAFlags = SkToGrQuadAAFlags(set[i].fAAFlags);
-
- if (n > 0 &&
- (!GrTextureProxy::ProxiesAreCompatibleAsDynamicState(textures[i].fProxy.get(),
- textures[base].fProxy.get()) ||
- set[i].fImage->alphaType() != set[base].fImage->alphaType() ||
- !SkColorSpace::Equals(set[i].fImage->colorSpace(), set[base].fImage->colorSpace()))) {
- draw();
- base = i;
- n = 1;
- } else {
- ++n;
- }
- }
- draw();
-}
-
-// TODO (michaelludwig) - to be removed when drawBitmapRect doesn't need it anymore
-void SkGpuDevice::drawTextureProducer(GrTextureProducer* producer,
- const SkRect* srcRect,
- const SkRect* dstRect,
- SkCanvas::SrcRectConstraint constraint,
- const SkMatrix& viewMatrix,
- const SkPaint& paint,
- bool attemptDrawTexture) {
- // The texture refactor split the old logic of drawTextureProducer into the beginning of
- // drawImageQuad() and into the static draw_texture_producer. Replicate necessary logic that
- // drawImageQuad() handles.
- SkRect src;
- SkRect dst;
- SkMatrix srcToDst;
- ImageDrawMode mode = optimize_sample_area(SkISize::Make(producer->width(), producer->height()),
- srcRect, dstRect, nullptr, &src, &dst, &srcToDst);
- if (mode == ImageDrawMode::kSkip) {
- return;
- }
- // There's no dstClip to worry about and the producer is already made so we wouldn't be able
- // to tell it to use decals if we had to
- SkASSERT(mode != ImageDrawMode::kDecal);
-
- draw_texture_producer(fContext.get(), fRenderTargetContext.get(), this->clip(), viewMatrix,
- paint, producer, src, dst, /* clip */ nullptr, srcToDst,
- GrAA(paint.isAntiAlias()),
- paint.isAntiAlias() ? GrQuadAAFlags::kAll : GrQuadAAFlags::kNone,
- constraint, attemptDrawTexture);
+ GrBlurUtils::drawShapeWithMaskFilter(this->context(), fRenderTargetContext.get(), this->clip(),
+ shape, std::move(grPaint), viewMatrix, mf);
}