blob: 3bac37ed20171ecb8ac4874c363ea8320dea94cb [file] [log] [blame]
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001/*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "src/gpu/SkGpuDevice.h"
Hal Canaryc640d0d2018-06-13 09:59:02 -04009
Mike Kleinc0bd9f92019-04-23 12:05:21 -050010#include "include/core/SkImageFilter.h"
11#include "include/core/SkPathEffect.h"
12#include "include/core/SkPicture.h"
13#include "include/core/SkSurface.h"
14#include "include/core/SkVertices.h"
15#include "include/gpu/GrContext.h"
16#include "include/private/SkImageInfoPriv.h"
17#include "include/private/SkShadowFlags.h"
18#include "include/private/SkTo.h"
19#include "src/core/SkCanvasPriv.h"
20#include "src/core/SkClipStack.h"
21#include "src/core/SkDraw.h"
22#include "src/core/SkImageFilterCache.h"
23#include "src/core/SkLatticeIter.h"
24#include "src/core/SkMakeUnique.h"
25#include "src/core/SkPictureData.h"
26#include "src/core/SkRRectPriv.h"
27#include "src/core/SkRasterClip.h"
28#include "src/core/SkRecord.h"
29#include "src/core/SkSpecialImage.h"
30#include "src/core/SkStroke.h"
31#include "src/core/SkTLazy.h"
32#include "src/core/SkVertState.h"
33#include "src/core/SkWritePixelsRec.h"
34#include "src/gpu/GrBitmapTextureMaker.h"
35#include "src/gpu/GrBlurUtils.h"
36#include "src/gpu/GrContextPriv.h"
37#include "src/gpu/GrGpu.h"
38#include "src/gpu/GrImageTextureMaker.h"
39#include "src/gpu/GrRenderTargetContextPriv.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050040#include "src/gpu/GrStyle.h"
41#include "src/gpu/GrSurfaceProxyPriv.h"
42#include "src/gpu/GrTextureAdjuster.h"
43#include "src/gpu/GrTracing.h"
44#include "src/gpu/SkGr.h"
45#include "src/gpu/effects/GrBicubicEffect.h"
46#include "src/gpu/effects/GrTextureDomain.h"
Michael Ludwig663afe52019-06-03 16:46:19 -040047#include "src/gpu/geometry/GrShape.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050048#include "src/gpu/text/GrTextTarget.h"
49#include "src/image/SkImage_Base.h"
50#include "src/image/SkReadPixelsRec.h"
51#include "src/image/SkSurface_Gpu.h"
52#include "src/utils/SkUTF.h"
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000053
joshualittce894002016-01-11 13:29:31 -080054#define ASSERT_SINGLE_OWNER \
Robert Phillipsa41c6852019-02-07 10:44:10 -050055SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fContext->priv().singleOwner());)
joshualittce894002016-01-11 13:29:31 -080056
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000057
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000058///////////////////////////////////////////////////////////////////////////////
59
bsalomon74f681d2015-06-23 14:38:48 -070060/** Checks that the alpha type is legal and gets constructor flags. Returns false if device creation
61 should fail. */
62bool SkGpuDevice::CheckAlphaTypeAndGetFlags(
63 const SkImageInfo* info, SkGpuDevice::InitContents init, unsigned* flags) {
64 *flags = 0;
65 if (info) {
66 switch (info->alphaType()) {
67 case kPremul_SkAlphaType:
68 break;
69 case kOpaque_SkAlphaType:
70 *flags |= SkGpuDevice::kIsOpaque_Flag;
71 break;
72 default: // If it is unpremul or unknown don't try to render
73 return false;
74 }
75 }
76 if (kClear_InitContents == init) {
77 *flags |= kNeedClear_Flag;
78 }
79 return true;
80}
81
Robert Phillips9fab7e92016-11-17 12:45:04 -050082sk_sp<SkGpuDevice> SkGpuDevice::Make(GrContext* context,
83 sk_sp<GrRenderTargetContext> renderTargetContext,
robertphillips15c42ca2016-08-04 08:45:02 -070084 int width, int height,
85 InitContents init) {
Robert Phillips920d4882019-03-04 15:16:44 -050086 if (!renderTargetContext || context->priv().abandoned()) {
robertphillipsca6eafc2016-05-17 09:57:46 -070087 return nullptr;
88 }
89 unsigned flags;
90 if (!CheckAlphaTypeAndGetFlags(nullptr, init, &flags)) {
91 return nullptr;
92 }
Robert Phillips9fab7e92016-11-17 12:45:04 -050093 return sk_sp<SkGpuDevice>(new SkGpuDevice(context, std::move(renderTargetContext),
94 width, height, flags));
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000095}
96
robertphillips24e91282016-04-29 06:46:36 -070097sk_sp<SkGpuDevice> SkGpuDevice::Make(GrContext* context, SkBudgeted budgeted,
98 const SkImageInfo& info, int sampleCount,
Greg Daniele252f082017-10-23 16:05:23 -040099 GrSurfaceOrigin origin, const SkSurfaceProps* props,
100 GrMipMapped mipMapped, InitContents init) {
bsalomon74f681d2015-06-23 14:38:48 -0700101 unsigned flags;
102 if (!CheckAlphaTypeAndGetFlags(&info, init, &flags)) {
halcanary96fcdcc2015-08-27 07:41:13 -0700103 return nullptr;
bsalomon74f681d2015-06-23 14:38:48 -0700104 }
105
Brian Osman11052242016-10-27 14:47:55 -0400106 sk_sp<GrRenderTargetContext> renderTargetContext(MakeRenderTargetContext(context, budgeted,
107 info, sampleCount,
Greg Daniele252f082017-10-23 16:05:23 -0400108 origin, props,
109 mipMapped));
Brian Osman11052242016-10-27 14:47:55 -0400110 if (!renderTargetContext) {
halcanary96fcdcc2015-08-27 07:41:13 -0700111 return nullptr;
bsalomon74f681d2015-06-23 14:38:48 -0700112 }
113
Robert Phillips9fab7e92016-11-17 12:45:04 -0500114 return sk_sp<SkGpuDevice>(new SkGpuDevice(context, std::move(renderTargetContext),
robertphillipsca6eafc2016-05-17 09:57:46 -0700115 info.width(), info.height(), flags));
bsalomon74f681d2015-06-23 14:38:48 -0700116}
117
Brian Osman11052242016-10-27 14:47:55 -0400118static SkImageInfo make_info(GrRenderTargetContext* context, int w, int h, bool opaque) {
reed589a39e2016-08-20 07:59:19 -0700119 SkColorType colorType;
Brian Salomonf3569f02017-10-24 12:52:33 -0400120 if (!GrPixelConfigToColorType(context->colorSpaceInfo().config(), &colorType)) {
reed589a39e2016-08-20 07:59:19 -0700121 colorType = kUnknown_SkColorType;
122 }
Brian Salomonf3569f02017-10-24 12:52:33 -0400123 return SkImageInfo::Make(w, h, colorType, opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType,
124 context->colorSpaceInfo().refColorSpace());
reed589a39e2016-08-20 07:59:19 -0700125}
126
Robert Phillips9fab7e92016-11-17 12:45:04 -0500127SkGpuDevice::SkGpuDevice(GrContext* context, sk_sp<GrRenderTargetContext> renderTargetContext,
128 int width, int height, unsigned flags)
Brian Osman11052242016-10-27 14:47:55 -0400129 : INHERITED(make_info(renderTargetContext.get(), width, height,
130 SkToBool(flags & kIsOpaque_Flag)), renderTargetContext->surfaceProps())
Robert Phillips9fab7e92016-11-17 12:45:04 -0500131 , fContext(SkRef(context))
Brian Osman11052242016-10-27 14:47:55 -0400132 , fRenderTargetContext(std::move(renderTargetContext))
reed589a39e2016-08-20 07:59:19 -0700133{
robertphillips1f3923e2016-07-21 07:17:54 -0700134 fSize.set(width, height);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000135
bsalomone63ffef2016-02-05 07:17:34 -0800136 if (flags & kNeedClear_Flag) {
137 this->clearAll();
138 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000139}
140
Brian Osman11052242016-10-27 14:47:55 -0400141sk_sp<GrRenderTargetContext> SkGpuDevice::MakeRenderTargetContext(
142 GrContext* context,
143 SkBudgeted budgeted,
144 const SkImageInfo& origInfo,
145 int sampleCount,
146 GrSurfaceOrigin origin,
Greg Daniele252f082017-10-23 16:05:23 -0400147 const SkSurfaceProps* surfaceProps,
148 GrMipMapped mipMapped) {
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000149 if (kUnknown_SkColorType == origInfo.colorType() ||
150 origInfo.width() < 0 || origInfo.height() < 0) {
halcanary96fcdcc2015-08-27 07:41:13 -0700151 return nullptr;
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000152 }
153
bsalomonafe30052015-01-16 07:32:33 -0800154 if (!context) {
halcanary96fcdcc2015-08-27 07:41:13 -0700155 return nullptr;
bsalomonafe30052015-01-16 07:32:33 -0800156 }
157
Brian Osman2b23c4b2018-06-01 12:25:08 -0400158 GrPixelConfig config = SkImageInfo2GrPixelConfig(origInfo);
Greg Daniel0a7aa142018-02-21 13:02:32 -0500159 if (kUnknown_GrPixelConfig == config) {
160 return nullptr;
161 }
Greg Daniel4065d452018-11-16 15:43:41 -0500162 GrBackendFormat format =
Robert Phillips9da87e02019-02-04 13:26:26 -0500163 context->priv().caps()->getBackendFormatFromColorType(origInfo.colorType());
Robert Phillips0ae6faa2017-03-21 16:22:00 -0400164 // This method is used to create SkGpuDevice's for SkSurface_Gpus. In this case
165 // they need to be exact.
Robert Phillips9da87e02019-02-04 13:26:26 -0500166 return context->priv().makeDeferredRenderTargetContext(
Greg Daniel4065d452018-11-16 15:43:41 -0500167 format, SkBackingFit::kExact,
robertphillips6738c702016-07-27 12:13:51 -0700168 origInfo.width(), origInfo.height(),
Robert Phillips70b49fd2017-01-13 11:21:36 -0500169 config, origInfo.refColorSpace(), sampleCount,
Greg Daniel45d63032017-10-30 13:41:26 -0400170 mipMapped, origin, surfaceProps, budgeted);
kkinnunenabcfab42015-02-22 22:53:44 -0800171}
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000172
Mike Reeda1361362017-03-07 09:37:29 -0500173sk_sp<SkSpecialImage> SkGpuDevice::filterTexture(SkSpecialImage* srcImg,
robertphillips970587b2016-07-14 14:12:55 -0700174 int left, int top,
175 SkIPoint* offset,
176 const SkImageFilter* filter) {
177 SkASSERT(srcImg->isTextureBacked());
178 SkASSERT(filter);
179
Mike Reeda1361362017-03-07 09:37:29 -0500180 SkMatrix matrix = this->ctm();
robertphillips970587b2016-07-14 14:12:55 -0700181 matrix.postTranslate(SkIntToScalar(-left), SkIntToScalar(-top));
Mike Reeda1361362017-03-07 09:37:29 -0500182 const SkIRect clipBounds = this->devClipBounds().makeOffset(-left, -top);
Hal Canary144caf52016-11-07 17:57:18 -0500183 sk_sp<SkImageFilterCache> cache(this->getImageFilterCache());
Brian Osmana50205f2018-07-06 13:57:01 -0400184 SkColorType colorType;
185 if (!GrPixelConfigToColorType(fRenderTargetContext->colorSpaceInfo().config(), &colorType)) {
186 colorType = kN32_SkColorType;
187 }
Brian Salomonf3569f02017-10-24 12:52:33 -0400188 SkImageFilter::OutputProperties outputProperties(
Brian Osmana50205f2018-07-06 13:57:01 -0400189 colorType, fRenderTargetContext->colorSpaceInfo().colorSpace());
brianosman2a75e5d2016-09-22 07:15:37 -0700190 SkImageFilter::Context ctx(matrix, clipBounds, cache.get(), outputProperties);
robertphillips970587b2016-07-14 14:12:55 -0700191
192 return filter->filterImage(srcImg, ctx, offset);
193}
194
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000195///////////////////////////////////////////////////////////////////////////////
196
Mike Reed353196f2017-07-21 11:01:18 -0400197bool SkGpuDevice::onReadPixels(const SkPixmap& pm, int x, int y) {
joshualittce894002016-01-11 13:29:31 -0800198 ASSERT_SINGLE_OWNER
commit-bot@chromium.orga713f9c2014-03-17 21:31:26 +0000199
Mike Reed353196f2017-07-21 11:01:18 -0400200 if (!SkImageInfoValidConversion(pm.info(), this->imageInfo())) {
Matt Sarettcb6266b2017-01-17 10:48:53 -0500201 return false;
202 }
203
Mike Reed353196f2017-07-21 11:01:18 -0400204 SkReadPixelsRec rec(pm, x, y);
Matt Sarett03dd6d52017-01-23 12:15:09 -0500205 if (!rec.trim(this->width(), this->height())) {
206 return false;
207 }
208
209 return fRenderTargetContext->readPixels(rec.fInfo, rec.fPixels, rec.fRowBytes, rec.fX, rec.fY);
commit-bot@chromium.orga713f9c2014-03-17 21:31:26 +0000210}
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000211
Mike Reed353196f2017-07-21 11:01:18 -0400212bool SkGpuDevice::onWritePixels(const SkPixmap& pm, int x, int y) {
joshualittce894002016-01-11 13:29:31 -0800213 ASSERT_SINGLE_OWNER
robertphillips1da3ecd2016-08-31 14:54:15 -0700214
Mike Reed353196f2017-07-21 11:01:18 -0400215 if (!SkImageInfoValidConversion(this->imageInfo(), pm.info())) {
Matt Sarettcb6266b2017-01-17 10:48:53 -0500216 return false;
217 }
218
Mike Reed353196f2017-07-21 11:01:18 -0400219 SkWritePixelsRec rec(pm, x, y);
Matt Sarett03dd6d52017-01-23 12:15:09 -0500220 if (!rec.trim(this->width(), this->height())) {
221 return false;
222 }
223
224 return fRenderTargetContext->writePixels(rec.fInfo, rec.fPixels, rec.fRowBytes, rec.fX, rec.fY);
commit-bot@chromium.org4cd9e212014-03-07 03:25:16 +0000225}
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000226
reed41e010c2015-06-09 12:16:53 -0700227bool SkGpuDevice::onAccessPixels(SkPixmap* pmap) {
joshualittce894002016-01-11 13:29:31 -0800228 ASSERT_SINGLE_OWNER
reed41e010c2015-06-09 12:16:53 -0700229 return false;
230}
231
Brian Osman11052242016-10-27 14:47:55 -0400232GrRenderTargetContext* SkGpuDevice::accessRenderTargetContext() {
robertphillips175dd9b2016-04-28 14:32:04 -0700233 ASSERT_SINGLE_OWNER
Brian Osman11052242016-10-27 14:47:55 -0400234 return fRenderTargetContext.get();
robertphillips175dd9b2016-04-28 14:32:04 -0700235}
236
reed8eddfb52014-12-04 07:50:14 -0800237void SkGpuDevice::clearAll() {
joshualittce894002016-01-11 13:29:31 -0800238 ASSERT_SINGLE_OWNER
Hal Canary144caf52016-11-07 17:57:18 -0500239 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "clearAll", fContext.get());
Robert Phillips784b7bf2016-12-09 13:35:02 -0500240
reed8eddfb52014-12-04 07:50:14 -0800241 SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
Brian Osman9a9baae2018-11-05 15:06:26 -0500242 fRenderTargetContext->clear(&rect, SK_PMColor4fTRANSPARENT,
243 GrRenderTargetContext::CanClearFullscreen::kYes);
reed8eddfb52014-12-04 07:50:14 -0800244}
245
Brian Salomonaad83152019-05-24 10:16:35 -0400246void SkGpuDevice::replaceRenderTargetContext(sk_sp<GrRenderTargetContext> rtc,
247 bool shouldRetainContent) {
248 SkASSERT(rtc->width() == this->width());
249 SkASSERT(rtc->height() == this->height());
250 SkASSERT(rtc->numColorSamples() == fRenderTargetContext->numColorSamples());
251 SkASSERT(rtc->numStencilSamples() == fRenderTargetContext->numStencilSamples());
252 SkASSERT(rtc->asSurfaceProxy()->priv().isExact());
253 if (shouldRetainContent) {
254 if (this->context()->abandoned()) {
255 return;
256 }
Greg Daniel46cfbc62019-06-07 11:43:30 -0400257
258 SkASSERT(fRenderTargetContext->asTextureProxy());
259 SkAssertResult(rtc->blitTexture(fRenderTargetContext->asTextureProxy(),
260 SkIRect::MakeWH(this->width(), this->height()),
261 SkIPoint::Make(0,0)));
Brian Salomonaad83152019-05-24 10:16:35 -0400262 }
263
264 fRenderTargetContext = std::move(rtc);
265}
266
Brian Osman11052242016-10-27 14:47:55 -0400267void SkGpuDevice::replaceRenderTargetContext(bool shouldRetainContent) {
joshualittce894002016-01-11 13:29:31 -0800268 ASSERT_SINGLE_OWNER
kkinnunenabcfab42015-02-22 22:53:44 -0800269
Brian Osman693a5402016-10-27 15:13:22 -0400270 SkBudgeted budgeted = fRenderTargetContext->priv().isBudgeted();
kkinnunenabcfab42015-02-22 22:53:44 -0800271
Robert Phillips0ae6faa2017-03-21 16:22:00 -0400272 // This entry point is used by SkSurface_Gpu::onCopyOnWrite so it must create a
273 // kExact-backed render target context.
Brian Osman693a5402016-10-27 15:13:22 -0400274 sk_sp<GrRenderTargetContext> newRTC(MakeRenderTargetContext(
Brian Osman11052242016-10-27 14:47:55 -0400275 this->context(),
276 budgeted,
277 this->imageInfo(),
Robert Phillips0ae6faa2017-03-21 16:22:00 -0400278 fRenderTargetContext->numColorSamples(),
279 fRenderTargetContext->origin(),
Greg Daniele252f082017-10-23 16:05:23 -0400280 &this->surfaceProps(),
281 fRenderTargetContext->mipMapped()));
Brian Osman693a5402016-10-27 15:13:22 -0400282 if (!newRTC) {
kkinnunenabcfab42015-02-22 22:53:44 -0800283 return;
284 }
Brian Salomonaad83152019-05-24 10:16:35 -0400285 this->replaceRenderTargetContext(std::move(newRTC), shouldRetainContent);
kkinnunenabcfab42015-02-22 22:53:44 -0800286}
287
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000288///////////////////////////////////////////////////////////////////////////////
289
Mike Reeda1361362017-03-07 09:37:29 -0500290void SkGpuDevice::drawPaint(const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800291 ASSERT_SINGLE_OWNER
Hal Canary144caf52016-11-07 17:57:18 -0500292 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPaint", fContext.get());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000293
294 GrPaint grPaint;
Brian Salomonf3569f02017-10-24 12:52:33 -0400295 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), paint,
296 this->ctm(), &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700297 return;
298 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000299
Brian Salomon0166cfd2017-03-13 17:58:25 -0400300 fRenderTargetContext->drawPaint(this->clip(), std::move(grPaint), this->ctm());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000301}
302
Brian Salomon1459ebd2017-12-19 16:12:44 -0500303static inline GrPrimitiveType point_mode_to_primitive_type(SkCanvas::PointMode mode) {
304 switch (mode) {
305 case SkCanvas::kPoints_PointMode:
306 return GrPrimitiveType::kPoints;
307 case SkCanvas::kLines_PointMode:
308 return GrPrimitiveType::kLines;
309 case SkCanvas::kPolygon_PointMode:
310 return GrPrimitiveType::kLineStrip;
311 }
312 SK_ABORT("Unexpected mode");
313 return GrPrimitiveType::kPoints;
314}
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000315
Mike Reeda1361362017-03-07 09:37:29 -0500316void SkGpuDevice::drawPoints(SkCanvas::PointMode mode,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000317 size_t count, const SkPoint pts[], const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800318 ASSERT_SINGLE_OWNER
Hal Canary144caf52016-11-07 17:57:18 -0500319 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPoints", fContext.get());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000320 SkScalar width = paint.getStrokeWidth();
321 if (width < 0) {
322 return;
323 }
324
commit-bot@chromium.org628ed0b2014-05-19 14:32:49 +0000325 if (paint.getPathEffect() && 2 == count && SkCanvas::kLines_PointMode == mode) {
bsalomon6663acf2016-05-10 09:14:17 -0700326 GrStyle style(paint, SkPaint::kStroke_Style);
egdaniele61c4112014-06-12 10:24:21 -0700327 GrPaint grPaint;
Brian Salomonf3569f02017-10-24 12:52:33 -0400328 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), paint,
329 this->ctm(), &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700330 return;
331 }
egdaniele61c4112014-06-12 10:24:21 -0700332 SkPath path;
jvanverthb3eb6872014-10-24 07:12:51 -0700333 path.setIsVolatile(true);
egdaniele61c4112014-06-12 10:24:21 -0700334 path.moveTo(pts[0]);
335 path.lineTo(pts[1]);
Chris Dalton3b51df12017-11-27 14:33:06 -0700336 fRenderTargetContext->drawPath(this->clip(), std::move(grPaint), GrAA(paint.isAntiAlias()),
337 this->ctm(), path, style);
egdaniele61c4112014-06-12 10:24:21 -0700338 return;
commit-bot@chromium.org628ed0b2014-05-19 14:32:49 +0000339 }
340
bsalomon6ade6dd2016-09-12 12:07:17 -0700341 SkScalar scales[2];
Mike Reeda1361362017-03-07 09:37:29 -0500342 bool isHairline = (0 == width) || (1 == width && this->ctm().getMinMaxScales(scales) &&
bsalomon6ade6dd2016-09-12 12:07:17 -0700343 SkScalarNearlyEqual(scales[0], 1.f) &&
344 SkScalarNearlyEqual(scales[1], 1.f));
ethannicholas330bb952015-07-17 06:44:02 -0700345 // we only handle non-antialiased hairlines and paints without path effects or mask filters,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000346 // else we let the SkDraw call our drawPath()
Ethan Nicholas2d78bcd2017-06-08 10:11:53 -0400347 if (!isHairline || paint.getPathEffect() || paint.getMaskFilter() || paint.isAntiAlias()) {
Mike Reeda1361362017-03-07 09:37:29 -0500348 SkRasterClip rc(this->devClipBounds());
349 SkDraw draw;
350 draw.fDst = SkPixmap(SkImageInfo::MakeUnknown(this->width(), this->height()), nullptr, 0);
351 draw.fMatrix = &this->ctm();
352 draw.fRC = &rc;
Mike Reed99330ba2017-02-22 11:01:08 -0500353 draw.drawPoints(mode, count, pts, paint, this);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000354 return;
355 }
356
Brian Salomon1459ebd2017-12-19 16:12:44 -0500357 GrPrimitiveType primitiveType = point_mode_to_primitive_type(mode);
bsalomon6ade6dd2016-09-12 12:07:17 -0700358
Mike Reeda1361362017-03-07 09:37:29 -0500359 const SkMatrix* viewMatrix = &this->ctm();
bsalomon6ade6dd2016-09-12 12:07:17 -0700360#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
361 // This offsetting in device space matches the expectations of the Android framework for non-AA
362 // points and lines.
363 SkMatrix tempMatrix;
Chris Dalton3809bab2017-06-13 10:55:06 -0600364 if (GrIsPrimTypeLines(primitiveType) || GrPrimitiveType::kPoints == primitiveType) {
bsalomon6ade6dd2016-09-12 12:07:17 -0700365 tempMatrix = *viewMatrix;
366 static const SkScalar kOffset = 0.063f; // Just greater than 1/16.
367 tempMatrix.postTranslate(kOffset, kOffset);
368 viewMatrix = &tempMatrix;
369 }
370#endif
371
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000372 GrPaint grPaint;
Brian Salomonf3569f02017-10-24 12:52:33 -0400373 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), paint,
374 *viewMatrix, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700375 return;
376 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000377
Brian Osmanae0c50c2017-05-25 16:56:34 -0400378 static constexpr SkVertices::VertexMode kIgnoredMode = SkVertices::kTriangles_VertexMode;
379 sk_sp<SkVertices> vertices = SkVertices::MakeCopy(kIgnoredMode, SkToS32(count), pts, nullptr,
380 nullptr);
381
382 fRenderTargetContext->drawVertices(this->clip(), std::move(grPaint), *viewMatrix,
Ruiqi Mao4ec72f72018-07-10 17:21:07 -0400383 std::move(vertices), nullptr, 0, &primitiveType);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000384}
385
386///////////////////////////////////////////////////////////////////////////////
387
Mike Reeda1361362017-03-07 09:37:29 -0500388void SkGpuDevice::drawRect(const SkRect& rect, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800389 ASSERT_SINGLE_OWNER
Hal Canary144caf52016-11-07 17:57:18 -0500390 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawRect", fContext.get());
Robert Phillips27927a52018-08-20 13:18:12 -0400391
392 GrStyle style(paint);
393
bsalomona7d85ba2016-07-06 11:54:59 -0700394 // A couple reasons we might need to call drawPath.
395 if (paint.getMaskFilter() || paint.getPathEffect()) {
Robert Phillips27927a52018-08-20 13:18:12 -0400396 GrShape shape(rect, style);
397
398 GrBlurUtils::drawShapeWithMaskFilter(fContext.get(), fRenderTargetContext.get(),
399 this->clip(), paint, this->ctm(), shape);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000400 return;
401 }
402
403 GrPaint grPaint;
Brian Salomonf3569f02017-10-24 12:52:33 -0400404 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), paint,
405 this->ctm(), &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700406 return;
407 }
Mike Klein744fb732014-06-23 15:13:26 -0400408
Chris Dalton3b51df12017-11-27 14:33:06 -0700409 fRenderTargetContext->drawRect(this->clip(), std::move(grPaint), GrAA(paint.isAntiAlias()),
410 this->ctm(), rect, &style);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000411}
412
Michael Ludwig390f0cc2019-03-19 09:16:38 -0400413void SkGpuDevice::drawEdgeAAQuad(const SkRect& rect, const SkPoint clip[4],
414 SkCanvas::QuadAAFlags aaFlags, SkColor color, SkBlendMode mode) {
Michael Ludwig75451902019-01-23 11:14:29 -0500415 ASSERT_SINGLE_OWNER
Michael Ludwig390f0cc2019-03-19 09:16:38 -0400416 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawEdgeAAQuad", fContext.get());
Michael Ludwig75451902019-01-23 11:14:29 -0500417
418 SkPMColor4f dstColor = SkColor4fPrepForDst(SkColor4f::FromColor(color),
Brian Osman8fa7ab42019-03-18 10:22:42 -0400419 fRenderTargetContext->colorSpaceInfo())
Michael Ludwig75451902019-01-23 11:14:29 -0500420 .premul();
421
422 GrPaint grPaint;
423 grPaint.setColor4f(dstColor);
424 if (mode != SkBlendMode::kSrcOver) {
425 grPaint.setXPFactory(SkBlendMode_AsXPFactory(mode));
426 }
427
Michael Ludwig136f45a2019-02-19 11:44:41 -0500428 // This is exclusively meant for tiling operations, so keep AA enabled to handle MSAA seaming
Michael Ludwig1433cfd2019-02-27 17:12:30 -0500429 GrQuadAAFlags grAA = SkToGrQuadAAFlags(aaFlags);
Michael Ludwig390f0cc2019-03-19 09:16:38 -0400430 if (clip) {
Michael Ludwig1433cfd2019-02-27 17:12:30 -0500431 // Use fillQuadWithEdgeAA
432 fRenderTargetContext->fillQuadWithEdgeAA(this->clip(), std::move(grPaint), GrAA::kYes, grAA,
433 this->ctm(), clip, nullptr);
434 } else {
435 // Use fillRectWithEdgeAA to preserve mathematical properties of dst being rectangular
436 fRenderTargetContext->fillRectWithEdgeAA(this->clip(), std::move(grPaint), GrAA::kYes, grAA,
437 this->ctm(), rect);
438 }
Michael Ludwig75451902019-01-23 11:14:29 -0500439}
440
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000441///////////////////////////////////////////////////////////////////////////////
442
Mike Reeda1361362017-03-07 09:37:29 -0500443void SkGpuDevice::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800444 ASSERT_SINGLE_OWNER
Hal Canary144caf52016-11-07 17:57:18 -0500445 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawRRect", fContext.get());
Robert Phillips27927a52018-08-20 13:18:12 -0400446
Mike Reed80747ef2018-01-23 15:29:32 -0500447 SkMaskFilterBase* mf = as_MFB(paint.getMaskFilter());
Mike Reedbfadcf02018-01-20 22:24:21 +0000448 if (mf) {
449 if (mf->hasFragmentProcessor()) {
450 mf = nullptr; // already handled in SkPaintToGrPaint
451 }
Robert Phillipsa29a9562016-10-20 09:40:55 -0400452 }
453
bsalomon6663acf2016-05-10 09:14:17 -0700454 GrStyle style(paint);
commit-bot@chromium.org82139702014-03-10 22:53:20 +0000455
Robert Phillipsa29a9562016-10-20 09:40:55 -0400456 if (mf || style.pathEffect()) {
robertphillipsff55b492015-11-24 07:56:59 -0800457 // A path effect will presumably transform this rrect into something else.
Robert Phillips27927a52018-08-20 13:18:12 -0400458 GrShape shape(rrect, style);
459
Robert Phillips27927a52018-08-20 13:18:12 -0400460 GrBlurUtils::drawShapeWithMaskFilter(fContext.get(), fRenderTargetContext.get(),
461 this->clip(), paint, this->ctm(), shape);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000462 return;
463 }
Mike Klein744fb732014-06-23 15:13:26 -0400464
bsalomon6663acf2016-05-10 09:14:17 -0700465 SkASSERT(!style.pathEffect());
robertphillips514450c2015-11-24 05:36:02 -0800466
Robert Phillipsa522d662018-08-23 13:50:16 -0400467 GrPaint grPaint;
468 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), paint,
469 this->ctm(), &grPaint)) {
470 return;
471 }
472
Chris Dalton3b51df12017-11-27 14:33:06 -0700473 fRenderTargetContext->drawRRect(this->clip(), std::move(grPaint), GrAA(paint.isAntiAlias()),
474 this->ctm(), rrect, style);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000475}
476
robertphillipsd7706102016-02-25 09:28:08 -0800477
Robert Phillips20390c32018-08-17 11:01:03 -0400478void SkGpuDevice::drawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800479 ASSERT_SINGLE_OWNER
Hal Canary144caf52016-11-07 17:57:18 -0500480 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawDRRect", fContext.get());
robertphillipsd7706102016-02-25 09:28:08 -0800481 if (outer.isEmpty()) {
482 return;
483 }
484
485 if (inner.isEmpty()) {
Mike Reeda1361362017-03-07 09:37:29 -0500486 return this->drawRRect(outer, paint);
robertphillipsd7706102016-02-25 09:28:08 -0800487 }
488
commit-bot@chromium.org0a09d712014-04-09 21:26:11 +0000489 SkStrokeRec stroke(paint);
commit-bot@chromium.org0a09d712014-04-09 21:26:11 +0000490
robertphillips0e7029e2015-11-30 05:45:06 -0800491 if (stroke.isFillStyle() && !paint.getMaskFilter() && !paint.getPathEffect()) {
robertphillips00095892016-02-29 13:50:40 -0800492 GrPaint grPaint;
Brian Salomonf3569f02017-10-24 12:52:33 -0400493 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), paint,
494 this->ctm(), &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700495 return;
496 }
robertphillips00095892016-02-29 13:50:40 -0800497
Brian Salomon0166cfd2017-03-13 17:58:25 -0400498 fRenderTargetContext->drawDRRect(this->clip(), std::move(grPaint),
Chris Dalton3b51df12017-11-27 14:33:06 -0700499 GrAA(paint.isAntiAlias()), this->ctm(), outer, inner);
robertphillips00095892016-02-29 13:50:40 -0800500 return;
commit-bot@chromium.org0a09d712014-04-09 21:26:11 +0000501 }
502
503 SkPath path;
jvanverthb3eb6872014-10-24 07:12:51 -0700504 path.setIsVolatile(true);
commit-bot@chromium.org0a09d712014-04-09 21:26:11 +0000505 path.addRRect(outer);
506 path.addRRect(inner);
507 path.setFillType(SkPath::kEvenOdd_FillType);
508
Robert Phillips27927a52018-08-20 13:18:12 -0400509 // TODO: We are losing the possible mutability of the path here but this should probably be
510 // fixed by upgrading GrShape to handle DRRects.
511 GrShape shape(path, paint);
512
513 GrBlurUtils::drawShapeWithMaskFilter(fContext.get(), fRenderTargetContext.get(), this->clip(),
514 paint, this->ctm(), shape);
commit-bot@chromium.org0a09d712014-04-09 21:26:11 +0000515}
516
517
commit-bot@chromium.org82139702014-03-10 22:53:20 +0000518/////////////////////////////////////////////////////////////////////////////
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000519
Mike Reeda1361362017-03-07 09:37:29 -0500520void SkGpuDevice::drawRegion(const SkRegion& region, const SkPaint& paint) {
msarettcc319b92016-08-25 18:07:18 -0700521 if (paint.getMaskFilter()) {
522 SkPath path;
523 region.getBoundaryPath(&path);
Robert Phillips137ca522018-08-15 10:14:33 -0400524 path.setIsVolatile(true);
525 return this->drawPath(path, paint, true);
msarettcc319b92016-08-25 18:07:18 -0700526 }
527
528 GrPaint grPaint;
Brian Salomonf3569f02017-10-24 12:52:33 -0400529 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), paint,
530 this->ctm(), &grPaint)) {
msarettcc319b92016-08-25 18:07:18 -0700531 return;
532 }
533
Chris Dalton3b51df12017-11-27 14:33:06 -0700534 fRenderTargetContext->drawRegion(this->clip(), std::move(grPaint), GrAA(paint.isAntiAlias()),
535 this->ctm(), region, GrStyle(paint));
msarettcc319b92016-08-25 18:07:18 -0700536}
537
Mike Reeda1361362017-03-07 09:37:29 -0500538void SkGpuDevice::drawOval(const SkRect& oval, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800539 ASSERT_SINGLE_OWNER
Hal Canary144caf52016-11-07 17:57:18 -0500540 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawOval", fContext.get());
herb11a7f7f2015-11-24 12:41:00 -0800541
robertphillips514450c2015-11-24 05:36:02 -0800542 if (paint.getMaskFilter()) {
543 // The RRect path can handle special case blurring
544 SkRRect rr = SkRRect::MakeOval(oval);
Mike Reeda1361362017-03-07 09:37:29 -0500545 return this->drawRRect(rr, paint);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000546 }
547
548 GrPaint grPaint;
Brian Salomonf3569f02017-10-24 12:52:33 -0400549 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), paint,
550 this->ctm(), &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700551 return;
552 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000553
Chris Dalton3b51df12017-11-27 14:33:06 -0700554 fRenderTargetContext->drawOval(this->clip(), std::move(grPaint), GrAA(paint.isAntiAlias()),
555 this->ctm(), oval, GrStyle(paint));
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000556}
557
Mike Reeda1361362017-03-07 09:37:29 -0500558void SkGpuDevice::drawArc(const SkRect& oval, SkScalar startAngle,
bsalomon4f3a0ca2016-08-22 13:14:26 -0700559 SkScalar sweepAngle, bool useCenter, const SkPaint& paint) {
560 ASSERT_SINGLE_OWNER
Hal Canary144caf52016-11-07 17:57:18 -0500561 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawArc", fContext.get());
bsalomon4f3a0ca2016-08-22 13:14:26 -0700562 if (paint.getMaskFilter()) {
Mike Reeda1361362017-03-07 09:37:29 -0500563 this->INHERITED::drawArc(oval, startAngle, sweepAngle, useCenter, paint);
bsalomon4f3a0ca2016-08-22 13:14:26 -0700564 return;
565 }
566 GrPaint grPaint;
Brian Salomonf3569f02017-10-24 12:52:33 -0400567 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), paint,
568 this->ctm(), &grPaint)) {
bsalomon4f3a0ca2016-08-22 13:14:26 -0700569 return;
570 }
571
Chris Dalton3b51df12017-11-27 14:33:06 -0700572 fRenderTargetContext->drawArc(this->clip(), std::move(grPaint), GrAA(paint.isAntiAlias()),
Mike Reeda1361362017-03-07 09:37:29 -0500573 this->ctm(), oval, startAngle, sweepAngle, useCenter,
Brian Salomon82f44312017-01-11 13:42:54 -0500574 GrStyle(paint));
bsalomon4f3a0ca2016-08-22 13:14:26 -0700575}
576
Mike Kleinc0bd9f92019-04-23 12:05:21 -0500577#include "include/core/SkMaskFilter.h"
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000578
579///////////////////////////////////////////////////////////////////////////////
robertphillips0851d2d2016-06-02 05:21:34 -0700580void SkGpuDevice::drawStrokedLine(const SkPoint points[2],
robertphillips0851d2d2016-06-02 05:21:34 -0700581 const SkPaint& origPaint) {
582 ASSERT_SINGLE_OWNER
Hal Canary144caf52016-11-07 17:57:18 -0500583 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawStrokedLine", fContext.get());
Brian Osman11052242016-10-27 14:47:55 -0400584 // Adding support for round capping would require a
585 // GrRenderTargetContext::fillRRectWithLocalMatrix entry point
robertphillips0851d2d2016-06-02 05:21:34 -0700586 SkASSERT(SkPaint::kRound_Cap != origPaint.getStrokeCap());
587 SkASSERT(SkPaint::kStroke_Style == origPaint.getStyle());
588 SkASSERT(!origPaint.getPathEffect());
589 SkASSERT(!origPaint.getMaskFilter());
590
591 const SkScalar halfWidth = 0.5f * origPaint.getStrokeWidth();
592 SkASSERT(halfWidth > 0);
593
594 SkVector v = points[1] - points[0];
595
596 SkScalar length = SkPoint::Normalize(&v);
597 if (!length) {
598 v.fX = 1.0f;
599 v.fY = 0.0f;
600 }
601
602 SkPaint newPaint(origPaint);
603 newPaint.setStyle(SkPaint::kFill_Style);
604
605 SkScalar xtraLength = 0.0f;
606 if (SkPaint::kButt_Cap != origPaint.getStrokeCap()) {
607 xtraLength = halfWidth;
608 }
609
610 SkPoint mid = points[0] + points[1];
611 mid.scale(0.5f);
612
613 SkRect rect = SkRect::MakeLTRB(mid.fX-halfWidth, mid.fY - 0.5f*length - xtraLength,
614 mid.fX+halfWidth, mid.fY + 0.5f*length + xtraLength);
615 SkMatrix m;
616 m.setSinCos(v.fX, -v.fY, mid.fX, mid.fY);
617
618 SkMatrix local = m;
619
Mike Reeda1361362017-03-07 09:37:29 -0500620 m.postConcat(this->ctm());
robertphillips0851d2d2016-06-02 05:21:34 -0700621
622 GrPaint grPaint;
Brian Salomonf3569f02017-10-24 12:52:33 -0400623 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), newPaint, m,
624 &grPaint)) {
robertphillips0851d2d2016-06-02 05:21:34 -0700625 return;
626 }
627
Brian Salomon82f44312017-01-11 13:42:54 -0500628 fRenderTargetContext->fillRectWithLocalMatrix(
Chris Dalton3b51df12017-11-27 14:33:06 -0700629 this->clip(), std::move(grPaint), GrAA(newPaint.isAntiAlias()), m, rect, local);
robertphillips0851d2d2016-06-02 05:21:34 -0700630}
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000631
Robert Phillips20390c32018-08-17 11:01:03 -0400632void SkGpuDevice::drawPath(const SkPath& origSrcPath, const SkPaint& paint, bool pathIsMutable) {
joshualittce894002016-01-11 13:29:31 -0800633 ASSERT_SINGLE_OWNER
Robert Phillips137ca522018-08-15 10:14:33 -0400634 if (!origSrcPath.isInverseFillType() && !paint.getPathEffect()) {
robertphillips0851d2d2016-06-02 05:21:34 -0700635 SkPoint points[2];
636 if (SkPaint::kStroke_Style == paint.getStyle() && paint.getStrokeWidth() > 0 &&
637 !paint.getMaskFilter() && SkPaint::kRound_Cap != paint.getStrokeCap() &&
Mike Reeda1361362017-03-07 09:37:29 -0500638 this->ctm().preservesRightAngles() && origSrcPath.isLine(points)) {
robertphillips0851d2d2016-06-02 05:21:34 -0700639 // Path-based stroking looks better for thin rects
Mike Reeda1361362017-03-07 09:37:29 -0500640 SkScalar strokeWidth = this->ctm().getMaxScale() * paint.getStrokeWidth();
robertphillipsf2204c92016-06-02 10:57:59 -0700641 if (strokeWidth >= 1.0f) {
Brian Salomon09d994e2016-12-21 11:14:46 -0500642 // Round capping support is currently disabled b.c. it would require a RRect
643 // GrDrawOp that takes a localMatrix.
Mike Reeda1361362017-03-07 09:37:29 -0500644 this->drawStrokedLine(points, paint);
robertphillips0851d2d2016-06-02 05:21:34 -0700645 return;
646 }
647 }
robertphillipsff55b492015-11-24 07:56:59 -0800648 }
649
Hal Canary144caf52016-11-07 17:57:18 -0500650 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPath", fContext.get());
Robert Phillips137ca522018-08-15 10:14:33 -0400651 if (!paint.getMaskFilter()) {
Brian Salomona3cf3652018-01-03 15:11:00 -0500652 GrPaint grPaint;
653 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), paint,
654 this->ctm(), &grPaint)) {
655 return;
656 }
657 fRenderTargetContext->drawPath(this->clip(), std::move(grPaint), GrAA(paint.isAntiAlias()),
658 this->ctm(), origSrcPath, GrStyle(paint));
659 return;
660 }
Robert Phillips27927a52018-08-20 13:18:12 -0400661
662 // TODO: losing possible mutability of 'origSrcPath' here
663 GrShape shape(origSrcPath, paint);
664
665 GrBlurUtils::drawShapeWithMaskFilter(fContext.get(), fRenderTargetContext.get(), this->clip(),
666 paint, this->ctm(), shape);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000667}
668
669static const int kBmpSmallTileSize = 1 << 10;
670
671static inline int get_tile_count(const SkIRect& srcRect, int tileSize) {
672 int tilesX = (srcRect.fRight / tileSize) - (srcRect.fLeft / tileSize) + 1;
673 int tilesY = (srcRect.fBottom / tileSize) - (srcRect.fTop / tileSize) + 1;
674 return tilesX * tilesY;
675}
676
reed85d91782015-09-10 14:33:38 -0700677static int determine_tile_size(const SkIRect& src, int maxTileSize) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000678 if (maxTileSize <= kBmpSmallTileSize) {
679 return maxTileSize;
680 }
681
682 size_t maxTileTotalTileSize = get_tile_count(src, maxTileSize);
683 size_t smallTotalTileSize = get_tile_count(src, kBmpSmallTileSize);
684
685 maxTileTotalTileSize *= maxTileSize * maxTileSize;
686 smallTotalTileSize *= kBmpSmallTileSize * kBmpSmallTileSize;
687
688 if (maxTileTotalTileSize > 2 * smallTotalTileSize) {
689 return kBmpSmallTileSize;
690 } else {
691 return maxTileSize;
692 }
693}
694
695// Given a bitmap, an optional src rect, and a context with a clip and matrix determine what
696// pixels from the bitmap are necessary.
robertphillipse5768742016-05-13 11:20:46 -0700697static void determine_clipped_src_rect(int width, int height,
joshualitt570d2f82015-02-25 13:19:48 -0800698 const GrClip& clip,
joshualitt5531d512014-12-17 15:50:11 -0800699 const SkMatrix& viewMatrix,
bsalomone553b642016-08-17 09:02:09 -0700700 const SkMatrix& srcToDstRect,
reed85d91782015-09-10 14:33:38 -0700701 const SkISize& imageSize,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000702 const SkRect* srcRectPtr,
703 SkIRect* clippedSrcIRect) {
robertphillipse5768742016-05-13 11:20:46 -0700704 clip.getConservativeBounds(width, height, clippedSrcIRect, nullptr);
bsalomone553b642016-08-17 09:02:09 -0700705 SkMatrix inv = SkMatrix::Concat(viewMatrix, srcToDstRect);
706 if (!inv.invert(&inv)) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000707 clippedSrcIRect->setEmpty();
708 return;
709 }
710 SkRect clippedSrcRect = SkRect::Make(*clippedSrcIRect);
711 inv.mapRect(&clippedSrcRect);
bsalomon49f085d2014-09-05 13:34:00 -0700712 if (srcRectPtr) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000713 if (!clippedSrcRect.intersect(*srcRectPtr)) {
714 clippedSrcIRect->setEmpty();
715 return;
716 }
717 }
718 clippedSrcRect.roundOut(clippedSrcIRect);
reed85d91782015-09-10 14:33:38 -0700719 SkIRect bmpBounds = SkIRect::MakeSize(imageSize);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000720 if (!clippedSrcIRect->intersect(bmpBounds)) {
721 clippedSrcIRect->setEmpty();
722 }
723}
724
Robert Phillips920d4882019-03-04 15:16:44 -0500725const GrCaps* SkGpuDevice::caps() const {
726 return fContext->priv().caps();
727}
728
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400729bool SkGpuDevice::shouldTileImageID(uint32_t imageID,
730 const SkIRect& imageRect,
reed85d91782015-09-10 14:33:38 -0700731 const SkMatrix& viewMatrix,
bsalomone553b642016-08-17 09:02:09 -0700732 const SkMatrix& srcToDstRect,
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400733 const GrSamplerState& params,
reed85d91782015-09-10 14:33:38 -0700734 const SkRect* srcRectPtr,
735 int maxTileSize,
736 int* tileSize,
737 SkIRect* clippedSubset) const {
joshualittce894002016-01-11 13:29:31 -0800738 ASSERT_SINGLE_OWNER
reed85d91782015-09-10 14:33:38 -0700739 // if it's larger than the max tile size, then we have no choice but tiling.
740 if (imageRect.width() > maxTileSize || imageRect.height() > maxTileSize) {
Brian Osman11052242016-10-27 14:47:55 -0400741 determine_clipped_src_rect(fRenderTargetContext->width(), fRenderTargetContext->height(),
Brian Salomon0166cfd2017-03-13 17:58:25 -0400742 this->clip(), viewMatrix, srcToDstRect, imageRect.size(),
743 srcRectPtr, clippedSubset);
reed85d91782015-09-10 14:33:38 -0700744 *tileSize = determine_tile_size(*clippedSubset, maxTileSize);
745 return true;
746 }
747
bsalomon1a1d0b82015-10-16 07:49:42 -0700748 // If the image would only produce 4 tiles of the smaller size, don't bother tiling it.
reed85d91782015-09-10 14:33:38 -0700749 const size_t area = imageRect.width() * imageRect.height();
750 if (area < 4 * kBmpSmallTileSize * kBmpSmallTileSize) {
751 return false;
752 }
753
reed85d91782015-09-10 14:33:38 -0700754 // At this point we know we could do the draw by uploading the entire bitmap
755 // as a texture. However, if the texture would be large compared to the
756 // cache size and we don't require most of it for this draw then tile to
757 // reduce the amount of upload and cache spill.
758
759 // assumption here is that sw bitmap size is a good proxy for its size as
760 // a texture
761 size_t bmpSize = area * sizeof(SkPMColor); // assume 32bit pixels
762 size_t cacheSize;
763 fContext->getResourceCacheLimits(nullptr, &cacheSize);
764 if (bmpSize < cacheSize / 2) {
765 return false;
766 }
767
bsalomon1a1d0b82015-10-16 07:49:42 -0700768 // Figure out how much of the src we will need based on the src rect and clipping. Reject if
769 // tiling memory savings would be < 50%.
Brian Salomon0166cfd2017-03-13 17:58:25 -0400770 determine_clipped_src_rect(fRenderTargetContext->width(), fRenderTargetContext->height(),
771 this->clip(), viewMatrix, srcToDstRect, imageRect.size(), srcRectPtr,
Brian Osman11052242016-10-27 14:47:55 -0400772 clippedSubset);
reed85d91782015-09-10 14:33:38 -0700773 *tileSize = kBmpSmallTileSize; // already know whole bitmap fits in one max sized tile.
774 size_t usedTileBytes = get_tile_count(*clippedSubset, kBmpSmallTileSize) *
Brian Osmand05cdc32017-02-06 13:24:47 -0500775 kBmpSmallTileSize * kBmpSmallTileSize *
776 sizeof(SkPMColor); // assume 32bit pixels;
reed85d91782015-09-10 14:33:38 -0700777
Brian Osmand05cdc32017-02-06 13:24:47 -0500778 return usedTileBytes * 2 < bmpSize;
reed85d91782015-09-10 14:33:38 -0700779}
780
reed85d91782015-09-10 14:33:38 -0700781bool SkGpuDevice::shouldTileImage(const SkImage* image, const SkRect* srcRectPtr,
782 SkCanvas::SrcRectConstraint constraint, SkFilterQuality quality,
bsalomone553b642016-08-17 09:02:09 -0700783 const SkMatrix& viewMatrix,
784 const SkMatrix& srcToDstRect) const {
joshualittce894002016-01-11 13:29:31 -0800785 ASSERT_SINGLE_OWNER
Brian Salomon34169692017-08-28 15:32:01 -0400786 // If image is explicitly texture backed then we shouldn't get here.
787 SkASSERT(!image->isTextureBacked());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000788
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400789 GrSamplerState samplerState;
reed85d91782015-09-10 14:33:38 -0700790 bool doBicubic;
Brian Osmandb78cba2018-02-15 10:09:48 -0500791 GrSamplerState::Filter textureFilterMode = GrSkFilterQualityToGrFilterMode(
Robert Phillipsc1541ae2019-02-04 12:05:37 -0500792 quality, viewMatrix, srcToDstRect,
Robert Phillips9da87e02019-02-04 13:26:26 -0500793 fContext->priv().options().fSharpenMipmappedTextures, &doBicubic);
reed85d91782015-09-10 14:33:38 -0700794
795 int tileFilterPad;
796 if (doBicubic) {
797 tileFilterPad = GrBicubicEffect::kFilterTexelPad;
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400798 } else if (GrSamplerState::Filter::kNearest == textureFilterMode) {
reed85d91782015-09-10 14:33:38 -0700799 tileFilterPad = 0;
800 } else {
801 tileFilterPad = 1;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000802 }
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400803 samplerState.setFilterMode(textureFilterMode);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000804
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400805 int maxTileSize = this->caps()->maxTileSize() - 2 * tileFilterPad;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000806
reed85d91782015-09-10 14:33:38 -0700807 // these are output, which we safely ignore, as we just want to know the predicate
808 int outTileSize;
809 SkIRect outClippedSrcRect;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000810
bsalomone553b642016-08-17 09:02:09 -0700811 return this->shouldTileImageID(image->unique(), image->bounds(), viewMatrix, srcToDstRect,
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400812 samplerState, srcRectPtr, maxTileSize, &outTileSize,
bsalomone553b642016-08-17 09:02:09 -0700813 &outClippedSrcRect);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000814}
815
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000816// This method outsets 'iRect' by 'outset' all around and then clamps its extents to
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000817// 'clamp'. 'offset' is adjusted to remain positioned over the top-left corner
818// of 'iRect' for all possible outsets/clamps.
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000819static inline void clamped_outset_with_offset(SkIRect* iRect,
820 int outset,
821 SkPoint* offset,
822 const SkIRect& clamp) {
823 iRect->outset(outset, outset);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000824
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000825 int leftClampDelta = clamp.fLeft - iRect->fLeft;
826 if (leftClampDelta > 0) {
827 offset->fX -= outset - leftClampDelta;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000828 iRect->fLeft = clamp.fLeft;
829 } else {
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000830 offset->fX -= outset;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000831 }
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000832
833 int topClampDelta = clamp.fTop - iRect->fTop;
834 if (topClampDelta > 0) {
835 offset->fY -= outset - topClampDelta;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000836 iRect->fTop = clamp.fTop;
837 } else {
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000838 offset->fY -= outset;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000839 }
840
841 if (iRect->fRight > clamp.fRight) {
842 iRect->fRight = clamp.fRight;
843 }
844 if (iRect->fBottom > clamp.fBottom) {
845 iRect->fBottom = clamp.fBottom;
846 }
847}
848
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000849// Break 'bitmap' into several tiles to draw it since it has already
850// been determined to be too large to fit in VRAM
851void SkGpuDevice::drawTiledBitmap(const SkBitmap& bitmap,
joshualitt5531d512014-12-17 15:50:11 -0800852 const SkMatrix& viewMatrix,
bsalomone553b642016-08-17 09:02:09 -0700853 const SkMatrix& dstMatrix,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000854 const SkRect& srcRect,
855 const SkIRect& clippedSrcIRect,
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400856 const GrSamplerState& params,
bsalomonc55271f2015-11-09 11:55:57 -0800857 const SkPaint& origPaint,
reeda5517e22015-07-14 10:54:12 -0700858 SkCanvas::SrcRectConstraint constraint,
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000859 int tileSize,
860 bool bicubic) {
joshualittce894002016-01-11 13:29:31 -0800861 ASSERT_SINGLE_OWNER
ericrk369e9372016-02-05 15:32:36 -0800862
ericrk983294f2016-04-18 09:14:00 -0700863 // This is the funnel for all paths that draw tiled bitmaps/images. Log histogram entries.
ericrk369e9372016-02-05 15:32:36 -0800864 SK_HISTOGRAM_BOOLEAN("DrawTiled", true);
Michael Ludwig3e2cc062019-02-19 12:11:40 -0500865 LogDrawScaleFactor(viewMatrix, SkMatrix::I(), origPaint.getFilterQuality());
ericrk369e9372016-02-05 15:32:36 -0800866
bsalomonc55271f2015-11-09 11:55:57 -0800867 const SkPaint* paint = &origPaint;
868 SkPaint tempPaint;
Brian Salomon7c8460e2017-05-12 11:36:10 -0400869 if (origPaint.isAntiAlias() && GrFSAAType::kUnifiedMSAA != fRenderTargetContext->fsaaType()) {
bsalomonc55271f2015-11-09 11:55:57 -0800870 // Drop antialiasing to avoid seams at tile boundaries.
871 tempPaint = origPaint;
872 tempPaint.setAntiAlias(false);
873 paint = &tempPaint;
874 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000875 SkRect clippedSrcRect = SkRect::Make(clippedSrcIRect);
876
877 int nx = bitmap.width() / tileSize;
878 int ny = bitmap.height() / tileSize;
879 for (int x = 0; x <= nx; x++) {
880 for (int y = 0; y <= ny; y++) {
881 SkRect tileR;
882 tileR.set(SkIntToScalar(x * tileSize),
883 SkIntToScalar(y * tileSize),
884 SkIntToScalar((x + 1) * tileSize),
885 SkIntToScalar((y + 1) * tileSize));
886
887 if (!SkRect::Intersects(tileR, clippedSrcRect)) {
888 continue;
889 }
890
891 if (!tileR.intersect(srcRect)) {
892 continue;
893 }
894
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000895 SkIRect iTileR;
896 tileR.roundOut(&iTileR);
bsalomone553b642016-08-17 09:02:09 -0700897 SkVector offset = SkPoint::Make(SkIntToScalar(iTileR.fLeft),
898 SkIntToScalar(iTileR.fTop));
Brian Osmana950a862017-02-06 16:48:57 -0500899 SkRect rectToDraw = tileR;
bsalomone553b642016-08-17 09:02:09 -0700900 dstMatrix.mapRect(&rectToDraw);
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400901 if (GrSamplerState::Filter::kNearest != params.filter() || bicubic) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000902 SkIRect iClampRect;
903
reeda5517e22015-07-14 10:54:12 -0700904 if (SkCanvas::kFast_SrcRectConstraint == constraint) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000905 // In bleed mode we want to always expand the tile on all edges
906 // but stay within the bitmap bounds
907 iClampRect = SkIRect::MakeWH(bitmap.width(), bitmap.height());
908 } else {
909 // In texture-domain/clamp mode we only want to expand the
910 // tile on edges interior to "srcRect" (i.e., we want to
911 // not bleed across the original clamped edges)
912 srcRect.roundOut(&iClampRect);
913 }
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000914 int outset = bicubic ? GrBicubicEffect::kFilterTexelPad : 1;
915 clamped_outset_with_offset(&iTileR, outset, &offset, iClampRect);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000916 }
917
bsalomone553b642016-08-17 09:02:09 -0700918 SkBitmap tmpB;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000919 if (bitmap.extractSubset(&tmpB, iTileR)) {
920 // now offset it to make it "local" to our tmp bitmap
921 tileR.offset(-offset.fX, -offset.fY);
bsalomonb1b01992015-11-18 10:56:08 -0800922 // de-optimized this determination
923 bool needsTextureDomain = true;
bsalomone553b642016-08-17 09:02:09 -0700924 this->drawBitmapTile(tmpB,
925 viewMatrix,
926 rectToDraw,
927 tileR,
Robert Phillipse14d3052017-02-15 13:18:21 -0500928 params,
bsalomone553b642016-08-17 09:02:09 -0700929 *paint,
930 constraint,
931 bicubic,
932 needsTextureDomain);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000933 }
934 }
935 }
936}
937
bsalomone553b642016-08-17 09:02:09 -0700938void SkGpuDevice::drawBitmapTile(const SkBitmap& bitmap,
939 const SkMatrix& viewMatrix,
940 const SkRect& dstRect,
941 const SkRect& srcRect,
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400942 const GrSamplerState& samplerState,
bsalomone553b642016-08-17 09:02:09 -0700943 const SkPaint& paint,
944 SkCanvas::SrcRectConstraint constraint,
945 bool bicubic,
946 bool needsTextureDomain) {
bsalomon9c586542015-11-02 12:33:21 -0800947 // We should have already handled bitmaps larger than the max texture size.
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400948 SkASSERT(bitmap.width() <= this->caps()->maxTextureSize() &&
949 bitmap.height() <= this->caps()->maxTextureSize());
reedc7ec7c92016-07-25 08:29:10 -0700950 // We should be respecting the max tile size by the time we get here.
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400951 SkASSERT(bitmap.width() <= this->caps()->maxTileSize() &&
952 bitmap.height() <= this->caps()->maxTileSize());
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400953 SkASSERT(!samplerState.isRepeated());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000954
Brian Salomon2a943df2018-05-04 13:43:19 -0400955 SkScalar scales[2] = {1.f, 1.f};
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400956 sk_sp<GrTextureProxy> proxy =
Brian Salomon2a943df2018-05-04 13:43:19 -0400957 GrRefCachedBitmapTextureProxy(fContext.get(), bitmap, samplerState, scales);
Robert Phillips78075802017-03-23 11:11:59 -0400958 if (!proxy) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000959 return;
960 }
bsalomone553b642016-08-17 09:02:09 -0700961
bsalomone553b642016-08-17 09:02:09 -0700962 // Compute a matrix that maps the rect we will draw to the src rect.
Brian Salomon2a943df2018-05-04 13:43:19 -0400963 SkMatrix texMatrix = SkMatrix::MakeRectToRect(dstRect, srcRect, SkMatrix::kFill_ScaleToFit);
964 texMatrix.postScale(scales[0], scales[1]);
joshualitt5f10b5c2015-07-09 10:24:35 -0700965
966 // Construct a GrPaint by setting the bitmap texture as the first effect and then configuring
967 // the rest from the SkPaint.
Brian Salomonaff329b2017-08-11 09:40:37 -0400968 std::unique_ptr<GrFragmentProcessor> fp;
joshualitt5f10b5c2015-07-09 10:24:35 -0700969
Brian Salomonf9a86882019-06-13 11:13:48 -0400970 static constexpr auto kBicubicKernel = GrBicubicEffect::Kernel::kMitchell;
reeda5517e22015-07-14 10:54:12 -0700971 if (needsTextureDomain && (SkCanvas::kStrict_SrcRectConstraint == constraint)) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000972 // Use a constrained texture domain to avoid color bleeding
bsalomone553b642016-08-17 09:02:09 -0700973 SkRect domain;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000974 if (srcRect.width() > SK_Scalar1) {
Robert Phillipse98234f2017-01-09 14:23:59 -0500975 domain.fLeft = srcRect.fLeft + 0.5f;
976 domain.fRight = srcRect.fRight - 0.5f;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000977 } else {
Robert Phillipse98234f2017-01-09 14:23:59 -0500978 domain.fLeft = domain.fRight = srcRect.centerX();
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000979 }
980 if (srcRect.height() > SK_Scalar1) {
Robert Phillipse98234f2017-01-09 14:23:59 -0500981 domain.fTop = srcRect.fTop + 0.5f;
982 domain.fBottom = srcRect.fBottom - 0.5f;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000983 } else {
Robert Phillipse98234f2017-01-09 14:23:59 -0500984 domain.fTop = domain.fBottom = srcRect.centerY();
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000985 }
commit-bot@chromium.org7d7f3142013-12-16 15:18:11 +0000986 if (bicubic) {
Brian Salomona86fc7a2019-05-28 20:42:58 -0400987 static constexpr auto kDir = GrBicubicEffect::Direction::kXY;
Brian Salomonf9a86882019-06-13 11:13:48 -0400988 fp = GrBicubicEffect::Make(std::move(proxy), texMatrix, domain, kBicubicKernel, kDir,
Brian Salomona86fc7a2019-05-28 20:42:58 -0400989 bitmap.alphaType());
commit-bot@chromium.org7d7f3142013-12-16 15:18:11 +0000990 } else {
Brian Osman2240be92017-10-18 13:15:13 -0400991 fp = GrTextureDomainEffect::Make(std::move(proxy), texMatrix, domain,
Brian Osman5e341672017-10-18 10:23:18 -0400992 GrTextureDomain::kClamp_Mode, samplerState.filter());
commit-bot@chromium.org7d7f3142013-12-16 15:18:11 +0000993 }
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000994 } else if (bicubic) {
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400995 SkASSERT(GrSamplerState::Filter::kNearest == samplerState.filter());
996 GrSamplerState::WrapMode wrapMode[2] = {samplerState.wrapModeX(), samplerState.wrapModeY()};
Brian Salomona86fc7a2019-05-28 20:42:58 -0400997 static constexpr auto kDir = GrBicubicEffect::Direction::kXY;
Brian Salomonf9a86882019-06-13 11:13:48 -0400998 fp = GrBicubicEffect::Make(std::move(proxy), texMatrix, wrapMode, kBicubicKernel, kDir,
999 bitmap.alphaType());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001000 } else {
Brian Osman2240be92017-10-18 13:15:13 -04001001 fp = GrSimpleTextureEffect::Make(std::move(proxy), texMatrix, samplerState);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001002 }
1003
Brian Osman21fc5ce2018-08-27 20:36:19 +00001004 fp = GrColorSpaceXformEffect::Make(std::move(fp), bitmap.colorSpace(), bitmap.alphaType(),
Brian Salomonf3569f02017-10-24 12:52:33 -04001005 fRenderTargetContext->colorSpaceInfo().colorSpace());
joshualitt33a5fce2015-11-18 13:28:51 -08001006 GrPaint grPaint;
Brian Salomonf3569f02017-10-24 12:52:33 -04001007 if (!SkPaintToGrPaintWithTexture(this->context(), fRenderTargetContext->colorSpaceInfo(), paint,
1008 viewMatrix, std::move(fp),
1009 kAlpha_8_SkColorType == bitmap.colorType(), &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -07001010 return;
1011 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001012
Brian Salomon0e8fc8b2016-12-09 15:10:07 -05001013 // Coverage-based AA would cause seams between tiles.
Chris Dalton3b51df12017-11-27 14:33:06 -07001014 GrAA aa = GrAA(paint.isAntiAlias() &&
1015 GrFSAAType::kNone != fRenderTargetContext->fsaaType());
Brian Salomon0166cfd2017-03-13 17:58:25 -04001016 fRenderTargetContext->drawRect(this->clip(), std::move(grPaint), aa, viewMatrix, dstRect);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001017}
1018
Mike Reeda1361362017-03-07 09:37:29 -05001019void SkGpuDevice::drawSprite(const SkBitmap& bitmap,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001020 int left, int top, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001021 ASSERT_SINGLE_OWNER
Hal Canary144caf52016-11-07 17:57:18 -05001022 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawSprite", fContext.get());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001023
Robert Phillips920d4882019-03-04 15:16:44 -05001024 if (fContext->priv().abandoned()) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001025 return;
1026 }
1027
Robert Phillipse14d3052017-02-15 13:18:21 -05001028 sk_sp<SkSpecialImage> srcImg = this->makeSpecial(bitmap);
1029 if (!srcImg) {
1030 return;
joshualitt5f5a8d72015-02-25 14:09:45 -08001031 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001032
Florin Malita53f77bd2017-04-28 13:48:37 -04001033 this->drawSpecial(srcImg.get(), left, top, paint, nullptr, SkMatrix::I());
robertphillips970587b2016-07-14 14:12:55 -07001034}
1035
1036
Robert Phillipsc100d482018-07-10 10:11:01 -04001037void SkGpuDevice::drawSpecial(SkSpecialImage* special, int left, int top, const SkPaint& paint,
Robert Phillips213ce182018-04-25 09:13:28 -04001038 SkImage* clipImage, const SkMatrix& clipMatrix) {
robertphillips1b5f9682016-07-15 08:01:12 -07001039 ASSERT_SINGLE_OWNER
Hal Canary144caf52016-11-07 17:57:18 -05001040 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawSpecial", fContext.get());
robertphillips970587b2016-07-14 14:12:55 -07001041
robertphillips970587b2016-07-14 14:12:55 -07001042 sk_sp<SkSpecialImage> result;
1043 if (paint.getImageFilter()) {
Robert Phillipsc100d482018-07-10 10:11:01 -04001044 SkIPoint offset = { 0, 0 };
1045
1046 result = this->filterTexture(special, left, top, &offset, paint.getImageFilter());
robertphillips970587b2016-07-14 14:12:55 -07001047 if (!result) {
1048 return;
1049 }
Robert Phillipsc100d482018-07-10 10:11:01 -04001050
1051 left += offset.fX;
1052 top += offset.fY;
robertphillips970587b2016-07-14 14:12:55 -07001053 } else {
Robert Phillipsc100d482018-07-10 10:11:01 -04001054 result = sk_ref_sp(special);
robertphillips970587b2016-07-14 14:12:55 -07001055 }
1056
1057 SkASSERT(result->isTextureBacked());
Robert Phillips2c6d2bf2017-02-21 10:19:29 -05001058 sk_sp<GrTextureProxy> proxy = result->asTextureProxyRef(this->context());
Robert Phillips8e1c4e62017-02-19 12:27:01 -05001059 if (!proxy) {
Robert Phillips833dcf42016-11-18 08:44:13 -05001060 return;
1061 }
robertphillips970587b2016-07-14 14:12:55 -07001062
Robert Phillips8e1c4e62017-02-19 12:27:01 -05001063 const GrPixelConfig config = proxy->config();
1064
Michael Ludwigbeb7cd22019-04-08 11:11:42 -04001065 SkMatrix ctm = this->ctm();
1066 ctm.postTranslate(-SkIntToScalar(left), -SkIntToScalar(top));
1067
robertphillips970587b2016-07-14 14:12:55 -07001068 SkPaint tmpUnfiltered(paint);
Mike Reed2179b782018-02-07 11:59:57 -05001069 if (tmpUnfiltered.getMaskFilter()) {
Florin Malitac6c5ead2018-04-11 15:33:40 -04001070 tmpUnfiltered.setMaskFilter(tmpUnfiltered.getMaskFilter()->makeWithMatrix(ctm));
Mike Reed2179b782018-02-07 11:59:57 -05001071 }
1072
robertphillips970587b2016-07-14 14:12:55 -07001073 tmpUnfiltered.setImageFilter(nullptr);
1074
Brian Osman2240be92017-10-18 13:15:13 -04001075 auto fp = GrSimpleTextureEffect::Make(std::move(proxy), SkMatrix::I());
Brian Osman21fc5ce2018-08-27 20:36:19 +00001076 fp = GrColorSpaceXformEffect::Make(std::move(fp), result->getColorSpace(), result->alphaType(),
Brian Salomonf3569f02017-10-24 12:52:33 -04001077 fRenderTargetContext->colorSpaceInfo().colorSpace());
Robert Phillips8e1c4e62017-02-19 12:27:01 -05001078 if (GrPixelConfigIsAlphaOnly(config)) {
Brian Salomon22af73f2017-01-26 11:25:12 -05001079 fp = GrFragmentProcessor::MakeInputPremulAndMulByOutput(std::move(fp));
bsalomonf1b7a1d2015-09-28 06:26:28 -07001080 } else {
Brian Salomonc0d79e52019-04-10 15:02:11 -04001081 if (paint.getColor4f().isOpaque()) {
1082 fp = GrFragmentProcessor::OverrideInput(std::move(fp), SK_PMColor4fWHITE, false);
1083 } else {
1084 fp = GrFragmentProcessor::MulChildByInputAlpha(std::move(fp));
1085 }
bsalomonf1b7a1d2015-09-28 06:26:28 -07001086 }
Robert Phillips8e1c4e62017-02-19 12:27:01 -05001087
1088 GrPaint grPaint;
Brian Salomonf3569f02017-10-24 12:52:33 -04001089 if (!SkPaintToGrPaintReplaceShader(this->context(), fRenderTargetContext->colorSpaceInfo(),
1090 tmpUnfiltered, std::move(fp), &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -07001091 return;
1092 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001093
robertphillips970587b2016-07-14 14:12:55 -07001094 const SkIRect& subset = result->subset();
Michael Ludwigbeb7cd22019-04-08 11:11:42 -04001095 SkRect dstRect = SkRect::Make(SkIRect::MakeXYWH(left, top, subset.width(), subset.height()));
1096 SkRect srcRect = SkRect::Make(subset);
1097 if (clipImage) {
1098 // Add the image as a simple texture effect applied to coverage. Accessing content outside
1099 // of the clip image should behave as if it were a decal (i.e. zero coverage). However, to
1100 // limit pixels touched and hardware checks, we draw the clip image geometry to get the
1101 // decal effect.
1102 GrSamplerState sampler = paint.getFilterQuality() > kNone_SkFilterQuality ?
1103 GrSamplerState::ClampBilerp() : GrSamplerState::ClampNearest();
1104 sk_sp<GrTextureProxy> clipProxy = as_IB(clipImage)->asTextureProxyRef(this->context(),
1105 sampler, nullptr);
1106 // Fold clip matrix into ctm
1107 ctm.preConcat(clipMatrix);
1108 SkMatrix inverseClipMatrix;
robertphillips970587b2016-07-14 14:12:55 -07001109
Michael Ludwigbeb7cd22019-04-08 11:11:42 -04001110 std::unique_ptr<GrFragmentProcessor> cfp;
1111 if (clipProxy && ctm.invert(&inverseClipMatrix)) {
1112 cfp = GrSimpleTextureEffect::Make(std::move(clipProxy), inverseClipMatrix, sampler);
1113 if (clipImage->colorType() != kAlpha_8_SkColorType) {
1114 cfp = GrFragmentProcessor::SwizzleOutput(std::move(cfp), GrSwizzle::AAAA());
1115 }
1116 }
1117
1118 if (cfp) {
1119 // If the grPaint already has coverage, this adds an additional stage that multiples
1120 // the image's alpha channel with the prior coverage.
1121 grPaint.addCoverageFragmentProcessor(std::move(cfp));
1122
1123 // Undo the offset that was needed for shader coord transforms to get the transform for
1124 // the actual drawn geometry.
1125 ctm.postTranslate(SkIntToScalar(left), SkIntToScalar(top));
1126 inverseClipMatrix.preTranslate(-SkIntToScalar(left), -SkIntToScalar(top));
1127 SkRect clipGeometry = SkRect::MakeWH(clipImage->width(), clipImage->height());
1128 if (!clipGeometry.contains(inverseClipMatrix.mapRect(dstRect))) {
1129 // Draw the clip geometry since it is smaller, using dstRect as an extra scissor
1130 SkClipStack clip(this->cs());
1131 clip.clipDevRect(SkIRect::MakeXYWH(left, top, subset.width(), subset.height()),
1132 SkClipOp::kIntersect);
1133 SkMatrix local = SkMatrix::Concat(SkMatrix::MakeRectToRect(
1134 dstRect, srcRect, SkMatrix::kFill_ScaleToFit), ctm);
1135 fRenderTargetContext->fillRectWithLocalMatrix(GrClipStackClip(&clip),
1136 std::move(grPaint), GrAA(paint.isAntiAlias()), ctm, clipGeometry, local);
1137 return;
1138 }
1139 // Else fall through and draw the subset since that is contained in the clip geometry
1140 }
1141 // Else some issue configuring the coverage FP, so just draw without the clip mask image
1142 }
1143 // Draw directly in screen space, possibly with an extra coverage processor
1144 fRenderTargetContext->fillRectToRect(this->clip(), std::move(grPaint),
1145 GrAA(paint.isAntiAlias()), SkMatrix::I(), dstRect, srcRect);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001146}
1147
Mike Reeda1361362017-03-07 09:37:29 -05001148void SkGpuDevice::drawBitmapRect(const SkBitmap& bitmap,
bsalomonb1b01992015-11-18 10:56:08 -08001149 const SkRect* src, const SkRect& origDst,
reed562fe472015-07-28 07:35:14 -07001150 const SkPaint& paint, SkCanvas::SrcRectConstraint constraint) {
joshualittce894002016-01-11 13:29:31 -08001151 ASSERT_SINGLE_OWNER
bsalomonb1b01992015-11-18 10:56:08 -08001152 // The src rect is inferred to be the bmp bounds if not provided. Otherwise, the src rect must
1153 // be clipped to the bmp bounds. To determine tiling parameters we need the filter mode which
1154 // in turn requires knowing the src-to-dst mapping. If the src was clipped to the bmp bounds
1155 // then we use the src-to-dst mapping to compute a new clipped dst rect.
1156 const SkRect* dst = &origDst;
1157 const SkRect bmpBounds = SkRect::MakeIWH(bitmap.width(), bitmap.height());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001158 // Compute matrix from the two rectangles
bsalomonb1b01992015-11-18 10:56:08 -08001159 if (!src) {
1160 src = &bmpBounds;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001161 }
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +00001162
bsalomonb1b01992015-11-18 10:56:08 -08001163 SkMatrix srcToDstMatrix;
1164 if (!srcToDstMatrix.setRectToRect(*src, *dst, SkMatrix::kFill_ScaleToFit)) {
1165 return;
1166 }
1167 SkRect tmpSrc, tmpDst;
1168 if (src != &bmpBounds) {
1169 if (!bmpBounds.contains(*src)) {
1170 tmpSrc = *src;
1171 if (!tmpSrc.intersect(bmpBounds)) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001172 return; // nothing to draw
1173 }
bsalomonb1b01992015-11-18 10:56:08 -08001174 src = &tmpSrc;
1175 srcToDstMatrix.mapRect(&tmpDst, *src);
1176 dst = &tmpDst;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001177 }
1178 }
1179
Brian Salomonc7fe0f72018-05-11 10:14:21 -04001180 int maxTileSize = this->caps()->maxTileSize();
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +00001181
bsalomonb1b01992015-11-18 10:56:08 -08001182 // The tile code path doesn't currently support AA, so if the paint asked for aa and we could
1183 // draw untiled, then we bypass checking for tiling purely for optimization reasons.
Brian Salomon7c8460e2017-05-12 11:36:10 -04001184 bool useCoverageAA = GrFSAAType::kUnifiedMSAA != fRenderTargetContext->fsaaType() &&
1185 paint.isAntiAlias() && bitmap.width() <= maxTileSize &&
1186 bitmap.height() <= maxTileSize;
bsalomonb1b01992015-11-18 10:56:08 -08001187
Brian Salomon7c8460e2017-05-12 11:36:10 -04001188 bool skipTileCheck = useCoverageAA || paint.getMaskFilter();
bsalomonb1b01992015-11-18 10:56:08 -08001189
1190 if (!skipTileCheck) {
1191 int tileSize;
1192 SkIRect clippedSrcRect;
1193
Brian Salomon2bbdcc42017-09-07 12:36:34 -04001194 GrSamplerState sampleState;
bsalomonb1b01992015-11-18 10:56:08 -08001195 bool doBicubic;
Brian Salomon2bbdcc42017-09-07 12:36:34 -04001196 GrSamplerState::Filter textureFilterMode = GrSkFilterQualityToGrFilterMode(
Brian Osmandb78cba2018-02-15 10:09:48 -05001197 paint.getFilterQuality(), this->ctm(), srcToDstMatrix,
Robert Phillips9da87e02019-02-04 13:26:26 -05001198 fContext->priv().options().fSharpenMipmappedTextures, &doBicubic);
bsalomonb1b01992015-11-18 10:56:08 -08001199
1200 int tileFilterPad;
1201
1202 if (doBicubic) {
1203 tileFilterPad = GrBicubicEffect::kFilterTexelPad;
Brian Salomon2bbdcc42017-09-07 12:36:34 -04001204 } else if (GrSamplerState::Filter::kNearest == textureFilterMode) {
bsalomonb1b01992015-11-18 10:56:08 -08001205 tileFilterPad = 0;
1206 } else {
1207 tileFilterPad = 1;
1208 }
Brian Salomon2bbdcc42017-09-07 12:36:34 -04001209 sampleState.setFilterMode(textureFilterMode);
bsalomonb1b01992015-11-18 10:56:08 -08001210
Brian Salomonc7fe0f72018-05-11 10:14:21 -04001211 int maxTileSizeForFilter = this->caps()->maxTileSize() - 2 * tileFilterPad;
Mike Reeda1361362017-03-07 09:37:29 -05001212 if (this->shouldTileImageID(bitmap.getGenerationID(), bitmap.getSubset(), this->ctm(),
Brian Salomon2bbdcc42017-09-07 12:36:34 -04001213 srcToDstMatrix, sampleState, src, maxTileSizeForFilter,
1214 &tileSize, &clippedSrcRect)) {
Mike Reeda1361362017-03-07 09:37:29 -05001215 this->drawTiledBitmap(bitmap, this->ctm(), srcToDstMatrix, *src, clippedSrcRect,
Brian Salomon2bbdcc42017-09-07 12:36:34 -04001216 sampleState, paint, constraint, tileSize, doBicubic);
bsalomonb1b01992015-11-18 10:56:08 -08001217 return;
1218 }
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +00001219 }
Hal Canary144caf52016-11-07 17:57:18 -05001220 GrBitmapTextureMaker maker(fContext.get(), bitmap);
Jim Van Verth30e0d7f2018-11-02 13:36:42 -04001221 this->drawTextureProducer(&maker, src, dst, constraint, this->ctm(), paint, true);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001222}
1223
robertphillips6451a0c2016-07-18 08:31:31 -07001224sk_sp<SkSpecialImage> SkGpuDevice::makeSpecial(const SkBitmap& bitmap) {
Robert Phillipse14d3052017-02-15 13:18:21 -05001225 // TODO: this makes a tight copy of 'bitmap' but it doesn't have to be (given SkSpecialImage's
1226 // semantics). Since this is cached we would have to bake the fit into the cache key though.
Robert Phillips9da87e02019-02-04 13:26:26 -05001227 sk_sp<GrTextureProxy> proxy = GrMakeCachedBitmapProxy(fContext->priv().proxyProvider(),
Robert Phillips1afd4cd2018-01-08 13:40:32 -05001228 bitmap);
Robert Phillipse14d3052017-02-15 13:18:21 -05001229 if (!proxy) {
robertphillips6451a0c2016-07-18 08:31:31 -07001230 return nullptr;
1231 }
1232
Robert Phillipse14d3052017-02-15 13:18:21 -05001233 const SkIRect rect = SkIRect::MakeWH(proxy->width(), proxy->height());
robertphillips6451a0c2016-07-18 08:31:31 -07001234
Robert Phillipse14d3052017-02-15 13:18:21 -05001235 // GrMakeCachedBitmapProxy creates a tight copy of 'bitmap' so we don't have to subset
1236 // the special image
1237 return SkSpecialImage::MakeDeferredFromGpu(fContext.get(),
1238 rect,
1239 bitmap.getGenerationID(),
1240 std::move(proxy),
1241 bitmap.refColorSpace(),
1242 &this->surfaceProps());
robertphillips6451a0c2016-07-18 08:31:31 -07001243}
1244
reede51c3562016-07-19 14:33:20 -07001245sk_sp<SkSpecialImage> SkGpuDevice::makeSpecial(const SkImage* image) {
robertphillips6451a0c2016-07-18 08:31:31 -07001246 SkPixmap pm;
1247 if (image->isTextureBacked()) {
Robert Phillips6603a172019-03-05 12:35:44 -05001248 sk_sp<GrTextureProxy> proxy = as_IB(image)->asTextureProxyRef(this->context());
robertphillips6451a0c2016-07-18 08:31:31 -07001249
Robert Phillips6de99042017-01-31 11:31:39 -05001250 return SkSpecialImage::MakeDeferredFromGpu(fContext.get(),
1251 SkIRect::MakeWH(image->width(), image->height()),
1252 image->uniqueID(),
1253 std::move(proxy),
Brian Salomon5ad6fd32019-03-21 15:30:08 -04001254 image->refColorSpace(),
Robert Phillips6de99042017-01-31 11:31:39 -05001255 &this->surfaceProps());
robertphillips6451a0c2016-07-18 08:31:31 -07001256 } else if (image->peekPixels(&pm)) {
1257 SkBitmap bm;
1258
1259 bm.installPixels(pm);
1260 return this->makeSpecial(bm);
1261 } else {
1262 return nullptr;
1263 }
1264}
1265
1266sk_sp<SkSpecialImage> SkGpuDevice::snapSpecial() {
Greg Danielbe7fc462019-01-03 16:40:42 -05001267 // If we are wrapping a vulkan secondary command buffer, then we can't snap off a special image
1268 // since it would require us to make a copy of the underlying VkImage which we don't have access
1269 // to. Additionaly we can't stop and start the render pass that is used with the secondary
1270 // command buffer.
1271 if (this->accessRenderTargetContext()->wrapsVkSecondaryCB()) {
1272 return nullptr;
1273 }
1274
Robert Phillips63c67462017-02-15 14:19:01 -05001275 sk_sp<GrTextureProxy> proxy(this->accessRenderTargetContext()->asTextureProxyRef());
1276 if (!proxy) {
robertphillips04d62182016-07-15 12:21:33 -07001277 // When the device doesn't have a texture, we create a temporary texture.
1278 // TODO: we should actually only copy the portion of the source needed to apply the image
1279 // filter
Robert Phillips63c67462017-02-15 14:19:01 -05001280 proxy = GrSurfaceProxy::Copy(fContext.get(),
1281 this->accessRenderTargetContext()->asSurfaceProxy(),
Greg Daniel65c7f662017-10-30 13:39:09 -04001282 GrMipMapped::kNo,
Brian Salomonfee3f9b2018-12-19 12:34:12 -05001283 SkBackingFit::kApprox,
Robert Phillips63c67462017-02-15 14:19:01 -05001284 SkBudgeted::kYes);
1285 if (!proxy) {
robertphillips04d62182016-07-15 12:21:33 -07001286 return nullptr;
1287 }
robertphillips1b5f9682016-07-15 08:01:12 -07001288 }
1289
1290 const SkImageInfo ii = this->imageInfo();
1291 const SkIRect srcRect = SkIRect::MakeWH(ii.width(), ii.height());
1292
Robert Phillipse2f7d182016-12-15 09:23:05 -05001293 return SkSpecialImage::MakeDeferredFromGpu(fContext.get(),
1294 srcRect,
1295 kNeedNewImageUniqueID_SpecialImage,
Robert Phillips63c67462017-02-15 14:19:01 -05001296 std::move(proxy),
Robert Phillips70b49fd2017-01-13 11:21:36 -05001297 ii.refColorSpace(),
Robert Phillipse2f7d182016-12-15 09:23:05 -05001298 &this->surfaceProps());
robertphillips1b5f9682016-07-15 08:01:12 -07001299}
1300
Mike Reed148b7fd2018-12-18 17:38:18 -05001301sk_sp<SkSpecialImage> SkGpuDevice::snapBackImage(const SkIRect& subset) {
1302 GrRenderTargetContext* rtc = this->accessRenderTargetContext();
Greg Danielbe7fc462019-01-03 16:40:42 -05001303
1304 // If we are wrapping a vulkan secondary command buffer, then we can't snap off a special image
1305 // since it would require us to make a copy of the underlying VkImage which we don't have access
1306 // to. Additionaly we can't stop and start the render pass that is used with the secondary
1307 // command buffer.
1308 if (rtc->wrapsVkSecondaryCB()) {
Mike Reed148b7fd2018-12-18 17:38:18 -05001309 return nullptr;
1310 }
1311
Greg Danielbe7fc462019-01-03 16:40:42 -05001312
Mike Reed148b7fd2018-12-18 17:38:18 -05001313 GrContext* ctx = this->context();
Greg Danielbe7fc462019-01-03 16:40:42 -05001314 SkASSERT(rtc->asSurfaceProxy());
Mike Reed148b7fd2018-12-18 17:38:18 -05001315
Brian Salomonfee3f9b2018-12-19 12:34:12 -05001316 auto srcProxy =
1317 GrSurfaceProxy::Copy(ctx, rtc->asSurfaceProxy(), rtc->mipMapped(), subset,
1318 SkBackingFit::kApprox, rtc->asSurfaceProxy()->isBudgeted());
Mike Reed148b7fd2018-12-18 17:38:18 -05001319 if (!srcProxy) {
1320 return nullptr;
1321 }
1322
1323 // Note, can't move srcProxy since we also refer to this in the 2nd parameter
1324 return SkSpecialImage::MakeDeferredFromGpu(fContext.get(),
1325 SkIRect::MakeSize(srcProxy->isize()),
1326 kNeedNewImageUniqueID_SpecialImage,
1327 srcProxy,
1328 this->imageInfo().refColorSpace(),
1329 &this->surfaceProps());
1330}
1331
Mike Reeda1361362017-03-07 09:37:29 -05001332void SkGpuDevice::drawDevice(SkBaseDevice* device,
Mike Reed2179b782018-02-07 11:59:57 -05001333 int left, int top, const SkPaint& paint) {
1334 SkASSERT(!paint.getImageFilter());
reedcf5c8462016-07-20 12:28:40 -07001335
joshualittce894002016-01-11 13:29:31 -08001336 ASSERT_SINGLE_OWNER
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001337 // clear of the source device must occur before CHECK_SHOULD_DRAW
Hal Canary144caf52016-11-07 17:57:18 -05001338 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawDevice", fContext.get());
kkinnunen2e4414e2015-02-19 07:20:40 -08001339
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001340 // drawDevice is defined to be in device coords.
robertphillips1b5f9682016-07-15 08:01:12 -07001341 SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
robertphillips6451a0c2016-07-18 08:31:31 -07001342 sk_sp<SkSpecialImage> srcImg(dev->snapSpecial());
robertphillips1b5f9682016-07-15 08:01:12 -07001343 if (!srcImg) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001344 return;
1345 }
1346
Mike Reed2179b782018-02-07 11:59:57 -05001347 this->drawSpecial(srcImg.get(), left, top, paint, nullptr, SkMatrix::I());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001348}
1349
Brian Salomon34169692017-08-28 15:32:01 -04001350void SkGpuDevice::drawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
1351 const SkPaint& paint, SkCanvas::SrcRectConstraint constraint) {
joshualittce894002016-01-11 13:29:31 -08001352 ASSERT_SINGLE_OWNER
Michael Ludwig1433cfd2019-02-27 17:12:30 -05001353 GrQuadAAFlags aaFlags = paint.isAntiAlias() ? GrQuadAAFlags::kAll : GrQuadAAFlags::kNone;
Michael Ludwig7ae2ab52019-03-05 16:00:20 -05001354 this->drawImageQuad(image, src, &dst, nullptr, GrAA(paint.isAntiAlias()), aaFlags, nullptr,
1355 paint, constraint);
bsalomon1cf6f9b2015-12-08 10:53:43 -08001356}
1357
Leon Scroggins III57e1f022018-04-20 14:53:00 -04001358// When drawing nine-patches or n-patches, cap the filter quality at kBilerp.
1359static GrSamplerState::Filter compute_lattice_filter_mode(const SkPaint& paint) {
1360 if (paint.getFilterQuality() == kNone_SkFilterQuality) {
1361 return GrSamplerState::Filter::kNearest;
1362 }
1363
1364 return GrSamplerState::Filter::kBilerp;
1365}
1366
Mike Reeda1361362017-03-07 09:37:29 -05001367void SkGpuDevice::drawImageNine(const SkImage* image,
bsalomon2bbd0c62015-12-09 12:50:56 -08001368 const SkIRect& center, const SkRect& dst, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001369 ASSERT_SINGLE_OWNER
reed2d5b7142016-08-17 11:12:33 -07001370 uint32_t pinnedUniqueID;
Brian Salomon2a943df2018-05-04 13:43:19 -04001371 auto iter = skstd::make_unique<SkLatticeIter>(image->width(), image->height(), center, dst);
Robert Phillips6603a172019-03-05 12:35:44 -05001372 if (sk_sp<GrTextureProxy> proxy = as_IB(image)->refPinnedTextureProxy(this->context(),
1373 &pinnedUniqueID)) {
Brian Salomon5ad6fd32019-03-21 15:30:08 -04001374 GrTextureAdjuster adjuster(this->context(), std::move(proxy), image->alphaType(),
1375 pinnedUniqueID, image->colorSpace());
Brian Salomon2a943df2018-05-04 13:43:19 -04001376 this->drawProducerLattice(&adjuster, std::move(iter), dst, paint);
bsalomon2bbd0c62015-12-09 12:50:56 -08001377 } else {
1378 SkBitmap bm;
Brian Osmandf7e0752017-04-26 16:20:28 -04001379 if (image->isLazyGenerated()) {
1380 GrImageTextureMaker maker(fContext.get(), image, SkImage::kAllow_CachingHint);
Brian Salomon2a943df2018-05-04 13:43:19 -04001381 this->drawProducerLattice(&maker, std::move(iter), dst, paint);
Brian Osmane50cdf02018-10-19 13:02:14 -04001382 } else if (as_IB(image)->getROPixels(&bm)) {
Brian Salomon2a943df2018-05-04 13:43:19 -04001383 GrBitmapTextureMaker maker(fContext.get(), bm);
1384 this->drawProducerLattice(&maker, std::move(iter), dst, paint);
bsalomon2bbd0c62015-12-09 12:50:56 -08001385 }
1386 }
1387}
1388
Mike Reeda1361362017-03-07 09:37:29 -05001389void SkGpuDevice::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
bsalomon2bbd0c62015-12-09 12:50:56 -08001390 const SkRect& dst, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001391 ASSERT_SINGLE_OWNER
Brian Salomon2a943df2018-05-04 13:43:19 -04001392 auto iter = skstd::make_unique<SkLatticeIter>(bitmap.width(), bitmap.height(), center, dst);
Hal Canary144caf52016-11-07 17:57:18 -05001393 GrBitmapTextureMaker maker(fContext.get(), bitmap);
Brian Salomon2a943df2018-05-04 13:43:19 -04001394 this->drawProducerLattice(&maker, std::move(iter), dst, paint);
joshualitt33a5fce2015-11-18 13:28:51 -08001395}
1396
Mike Reeda1361362017-03-07 09:37:29 -05001397void SkGpuDevice::drawProducerLattice(GrTextureProducer* producer,
Brian Salomon2a943df2018-05-04 13:43:19 -04001398 std::unique_ptr<SkLatticeIter> iter, const SkRect& dst,
1399 const SkPaint& origPaint) {
Hal Canary144caf52016-11-07 17:57:18 -05001400 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawProducerLattice", fContext.get());
Brian Salomon2a943df2018-05-04 13:43:19 -04001401 SkTCopyOnFirstWrite<SkPaint> paint(&origPaint);
msarett10e3d9b2016-08-18 15:46:03 -07001402
Brian Salomon2a943df2018-05-04 13:43:19 -04001403 if (!producer->isAlphaOnly() && (paint->getColor() & 0x00FFFFFF) != 0x00FFFFFF) {
1404 paint.writable()->setColor(SkColorSetARGB(origPaint.getAlpha(), 0xFF, 0xFF, 0xFF));
1405 }
msarett10e3d9b2016-08-18 15:46:03 -07001406 GrPaint grPaint;
Brian Salomon2a943df2018-05-04 13:43:19 -04001407 if (!SkPaintToGrPaintWithPrimitiveColor(this->context(), fRenderTargetContext->colorSpaceInfo(),
1408 *paint, &grPaint)) {
msarett10e3d9b2016-08-18 15:46:03 -07001409 return;
1410 }
1411
Brian Salomon2a943df2018-05-04 13:43:19 -04001412 auto dstColorSpace = fRenderTargetContext->colorSpaceInfo().colorSpace();
1413 const GrSamplerState::Filter filter = compute_lattice_filter_mode(*paint);
Michael Ludwigddeed372019-02-20 16:50:10 -05001414 auto proxy = producer->refTextureProxyForParams(&filter, nullptr);
Brian Salomona8daee82018-05-07 14:51:18 -04001415 if (!proxy) {
1416 return;
1417 }
Brian Osman6064e1c2018-10-19 14:27:54 -04001418 auto csxf = GrColorSpaceXform::Make(producer->colorSpace(), producer->alphaType(),
1419 dstColorSpace, kPremul_SkAlphaType);
Brian Salomon2a943df2018-05-04 13:43:19 -04001420
Brian Salomon0166cfd2017-03-13 17:58:25 -04001421 fRenderTargetContext->drawImageLattice(this->clip(), std::move(grPaint), this->ctm(),
Brian Salomon2a943df2018-05-04 13:43:19 -04001422 std::move(proxy), std::move(csxf), filter,
1423 std::move(iter), dst);
msarett10e3d9b2016-08-18 15:46:03 -07001424}
1425
Mike Reeda1361362017-03-07 09:37:29 -05001426void SkGpuDevice::drawImageLattice(const SkImage* image,
msarett10e3d9b2016-08-18 15:46:03 -07001427 const SkCanvas::Lattice& lattice, const SkRect& dst,
1428 const SkPaint& paint) {
1429 ASSERT_SINGLE_OWNER
1430 uint32_t pinnedUniqueID;
Brian Salomon2a943df2018-05-04 13:43:19 -04001431 auto iter = skstd::make_unique<SkLatticeIter>(lattice, dst);
Robert Phillips6603a172019-03-05 12:35:44 -05001432 if (sk_sp<GrTextureProxy> proxy = as_IB(image)->refPinnedTextureProxy(this->context(),
1433 &pinnedUniqueID)) {
Brian Salomon5ad6fd32019-03-21 15:30:08 -04001434 GrTextureAdjuster adjuster(this->context(), std::move(proxy), image->alphaType(),
1435 pinnedUniqueID, image->colorSpace());
Brian Salomon2a943df2018-05-04 13:43:19 -04001436 this->drawProducerLattice(&adjuster, std::move(iter), dst, paint);
msarett10e3d9b2016-08-18 15:46:03 -07001437 } else {
1438 SkBitmap bm;
Brian Osmandf7e0752017-04-26 16:20:28 -04001439 if (image->isLazyGenerated()) {
1440 GrImageTextureMaker maker(fContext.get(), image, SkImage::kAllow_CachingHint);
Brian Salomon2a943df2018-05-04 13:43:19 -04001441 this->drawProducerLattice(&maker, std::move(iter), dst, paint);
Brian Osmane50cdf02018-10-19 13:02:14 -04001442 } else if (as_IB(image)->getROPixels(&bm)) {
Brian Salomon2a943df2018-05-04 13:43:19 -04001443 GrBitmapTextureMaker maker(fContext.get(), bm);
1444 this->drawProducerLattice(&maker, std::move(iter), dst, paint);
msarett10e3d9b2016-08-18 15:46:03 -07001445 }
1446 }
1447}
1448
Mike Reeda1361362017-03-07 09:37:29 -05001449void SkGpuDevice::drawBitmapLattice(const SkBitmap& bitmap,
msarett10e3d9b2016-08-18 15:46:03 -07001450 const SkCanvas::Lattice& lattice, const SkRect& dst,
1451 const SkPaint& paint) {
1452 ASSERT_SINGLE_OWNER
Brian Salomon2a943df2018-05-04 13:43:19 -04001453 auto iter = skstd::make_unique<SkLatticeIter>(lattice, dst);
Hal Canary144caf52016-11-07 17:57:18 -05001454 GrBitmapTextureMaker maker(fContext.get(), bitmap);
Brian Salomon2a943df2018-05-04 13:43:19 -04001455 this->drawProducerLattice(&maker, std::move(iter), dst, paint);
msarett10e3d9b2016-08-18 15:46:03 -07001456}
1457
Brian Salomonf3569f02017-10-24 12:52:33 -04001458static bool init_vertices_paint(GrContext* context, const GrColorSpaceInfo& colorSpaceInfo,
1459 const SkPaint& skPaint, const SkMatrix& matrix, SkBlendMode bmode,
Robert Phillips26c90e02017-03-14 14:39:29 -04001460 bool hasTexs, bool hasColors, GrPaint* grPaint) {
Brian Salomon199fb872017-02-06 09:41:10 -05001461 if (hasTexs && skPaint.getShader()) {
1462 if (hasColors) {
1463 // When there are texs and colors the shader and colors are combined using bmode.
Brian Salomonf3569f02017-10-24 12:52:33 -04001464 return SkPaintToGrPaintWithXfermode(context, colorSpaceInfo, skPaint, matrix, bmode,
1465 grPaint);
Brian Salomon199fb872017-02-06 09:41:10 -05001466 } else {
1467 // We have a shader, but no colors to blend it against.
Brian Salomonf3569f02017-10-24 12:52:33 -04001468 return SkPaintToGrPaint(context, colorSpaceInfo, skPaint, matrix, grPaint);
Brian Salomon199fb872017-02-06 09:41:10 -05001469 }
1470 } else {
1471 if (hasColors) {
1472 // We have colors, but either have no shader or no texture coords (which implies that
1473 // we should ignore the shader).
Brian Salomonf3569f02017-10-24 12:52:33 -04001474 return SkPaintToGrPaintWithPrimitiveColor(context, colorSpaceInfo, skPaint, grPaint);
Brian Salomon199fb872017-02-06 09:41:10 -05001475 } else {
1476 // No colors and no shaders. Just draw with the paint color.
Brian Salomonf3569f02017-10-24 12:52:33 -04001477 return SkPaintToGrPaintNoShader(context, colorSpaceInfo, skPaint, grPaint);
Brian Salomon199fb872017-02-06 09:41:10 -05001478 }
1479 }
1480}
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001481
Mike Reed887cdf12017-04-03 11:11:09 -04001482void SkGpuDevice::wireframeVertices(SkVertices::VertexMode vmode, int vertexCount,
Ruiqi Mao4ec72f72018-07-10 17:21:07 -04001483 const SkPoint vertices[],
Ruiqi Maoc97a3392018-08-15 10:44:19 -04001484 const SkVertices::Bone bones[], int boneCount,
Ruiqi Mao4ec72f72018-07-10 17:21:07 -04001485 SkBlendMode bmode,
Mike Reed2f6b5a42017-03-19 15:04:17 -04001486 const uint16_t indices[], int indexCount,
1487 const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001488 ASSERT_SINGLE_OWNER
Mike Reed2f6b5a42017-03-19 15:04:17 -04001489 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "wireframeVertices", fContext.get());
mtklein533eb782014-08-27 10:39:42 -07001490
Mike Reed2f6b5a42017-03-19 15:04:17 -04001491 SkPaint copy(paint);
1492 copy.setStyle(SkPaint::kStroke_Style);
1493 copy.setStrokeWidth(0);
mtklein533eb782014-08-27 10:39:42 -07001494
Mike Reed2f6b5a42017-03-19 15:04:17 -04001495 GrPaint grPaint;
1496 // we ignore the shader since we have no texture coordinates.
Brian Salomonf3569f02017-10-24 12:52:33 -04001497 if (!SkPaintToGrPaintNoShader(this->context(), fRenderTargetContext->colorSpaceInfo(), copy,
1498 &grPaint)) {
bsalomonf1b7a1d2015-09-28 06:26:28 -07001499 return;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001500 }
1501
Mike Reed2f6b5a42017-03-19 15:04:17 -04001502 int triangleCount = 0;
1503 int n = (nullptr == indices) ? vertexCount : indexCount;
1504 switch (vmode) {
Mike Reed887cdf12017-04-03 11:11:09 -04001505 case SkVertices::kTriangles_VertexMode:
Mike Reed2f6b5a42017-03-19 15:04:17 -04001506 triangleCount = n / 3;
1507 break;
Mike Reed887cdf12017-04-03 11:11:09 -04001508 case SkVertices::kTriangleStrip_VertexMode:
Mike Reed2f6b5a42017-03-19 15:04:17 -04001509 triangleCount = n - 2;
1510 break;
Brian Salomoncccafe82018-04-28 16:13:08 -04001511 case SkVertices::kTriangleFan_VertexMode:
1512 SK_ABORT("Unexpected triangle fan.");
1513 break;
Mike Reed2f6b5a42017-03-19 15:04:17 -04001514 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001515
Mike Reed2f6b5a42017-03-19 15:04:17 -04001516 VertState state(vertexCount, indices, indexCount);
1517 VertState::Proc vertProc = state.chooseProc(vmode);
1518
1519 //number of indices for lines per triangle with kLines
1520 indexCount = triangleCount * 6;
1521
Brian Osmanae0c50c2017-05-25 16:56:34 -04001522 static constexpr SkVertices::VertexMode kIgnoredMode = SkVertices::kTriangles_VertexMode;
1523 SkVertices::Builder builder(kIgnoredMode, vertexCount, indexCount, 0);
1524 memcpy(builder.positions(), vertices, vertexCount * sizeof(SkPoint));
1525
1526 uint16_t* lineIndices = builder.indices();
Mike Reed2f6b5a42017-03-19 15:04:17 -04001527 int i = 0;
1528 while (vertProc(&state)) {
1529 lineIndices[i] = state.f0;
1530 lineIndices[i + 1] = state.f1;
1531 lineIndices[i + 2] = state.f1;
1532 lineIndices[i + 3] = state.f2;
1533 lineIndices[i + 4] = state.f2;
1534 lineIndices[i + 5] = state.f0;
1535 i += 6;
bsalomonf1b7a1d2015-09-28 06:26:28 -07001536 }
Brian Osmanae0c50c2017-05-25 16:56:34 -04001537
Chris Dalton3809bab2017-06-13 10:55:06 -06001538 GrPrimitiveType primitiveType = GrPrimitiveType::kLines;
Brian Salomon0166cfd2017-03-13 17:58:25 -04001539 fRenderTargetContext->drawVertices(this->clip(),
Brian Salomon82f44312017-01-11 13:42:54 -05001540 std::move(grPaint),
Mike Reeda1361362017-03-07 09:37:29 -05001541 this->ctm(),
Brian Osmanae0c50c2017-05-25 16:56:34 -04001542 builder.detach(),
Ruiqi Mao4ec72f72018-07-10 17:21:07 -04001543 bones,
1544 boneCount,
Brian Osmanae0c50c2017-05-25 16:56:34 -04001545 &primitiveType);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001546}
1547
Ruiqi Maoc97a3392018-08-15 10:44:19 -04001548void SkGpuDevice::drawVertices(const SkVertices* vertices, const SkVertices::Bone bones[],
1549 int boneCount, SkBlendMode mode, const SkPaint& paint) {
Brian Salomon199fb872017-02-06 09:41:10 -05001550 ASSERT_SINGLE_OWNER
Mike Reed2f6b5a42017-03-19 15:04:17 -04001551 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawVertices", fContext.get());
Brian Salomon199fb872017-02-06 09:41:10 -05001552
1553 SkASSERT(vertices);
1554 GrPaint grPaint;
Mike Reed5fa66452017-03-16 09:06:34 -04001555 bool hasColors = vertices->hasColors();
1556 bool hasTexs = vertices->hasTexCoords();
Brian Osman0b403f82017-05-26 10:39:51 -04001557 if ((!hasTexs || !paint.getShader()) && !hasColors) {
Brian Salomon199fb872017-02-06 09:41:10 -05001558 // The dreaded wireframe mode. Fallback to drawVertices and go so slooooooow.
Mike Reed2f6b5a42017-03-19 15:04:17 -04001559 this->wireframeVertices(vertices->mode(), vertices->vertexCount(), vertices->positions(),
Ruiqi Mao4ec72f72018-07-10 17:21:07 -04001560 bones, boneCount, mode, vertices->indices(), vertices->indexCount(),
1561 paint);
Brian Osman0b403f82017-05-26 10:39:51 -04001562 return;
Brian Salomon199fb872017-02-06 09:41:10 -05001563 }
Brian Salomonf3569f02017-10-24 12:52:33 -04001564 if (!init_vertices_paint(fContext.get(), fRenderTargetContext->colorSpaceInfo(), paint,
1565 this->ctm(), mode, hasTexs, hasColors, &grPaint)) {
Brian Salomon199fb872017-02-06 09:41:10 -05001566 return;
1567 }
Brian Salomon0166cfd2017-03-13 17:58:25 -04001568 fRenderTargetContext->drawVertices(this->clip(), std::move(grPaint), this->ctm(),
Ruiqi Mao4ec72f72018-07-10 17:21:07 -04001569 sk_ref_sp(const_cast<SkVertices*>(vertices)),
1570 bones, boneCount);
Brian Salomon199fb872017-02-06 09:41:10 -05001571}
1572
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001573///////////////////////////////////////////////////////////////////////////////
1574
Jim Van Verth3af1af92017-05-18 15:06:54 -04001575void SkGpuDevice::drawShadow(const SkPath& path, const SkDrawShadowRec& rec) {
1576
1577 ASSERT_SINGLE_OWNER
Jim Van Verth3af1af92017-05-18 15:06:54 -04001578 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawShadow", fContext.get());
1579
Jim Van Verthb1b80f72018-01-18 15:19:13 -05001580 if (!fRenderTargetContext->drawFastShadow(this->clip(), this->ctm(), path, rec)) {
Jim Van Verth3af1af92017-05-18 15:06:54 -04001581 // failed to find an accelerated case
1582 this->INHERITED::drawShadow(path, rec);
1583 }
1584}
1585
1586///////////////////////////////////////////////////////////////////////////////
1587
Brian Osman4d92b892019-03-24 00:53:23 +00001588void SkGpuDevice::drawAtlas(const SkImage* atlas, const SkRSXform xform[],
1589 const SkRect texRect[], const SkColor colors[], int count,
1590 SkBlendMode mode, const SkPaint& paint) {
1591 ASSERT_SINGLE_OWNER
Brian Osmanddba4e62019-03-25 09:52:17 -04001592 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawAtlas", fContext.get());
Brian Osman4d92b892019-03-24 00:53:23 +00001593
1594 SkPaint p(paint);
1595 p.setShader(atlas->makeShader());
1596
1597 GrPaint grPaint;
1598 if (colors) {
1599 if (!SkPaintToGrPaintWithXfermode(this->context(), fRenderTargetContext->colorSpaceInfo(),
1600 p, this->ctm(), (SkBlendMode)mode, &grPaint)) {
1601 return;
1602 }
1603 } else {
1604 if (!SkPaintToGrPaint(this->context(), fRenderTargetContext->colorSpaceInfo(), p,
1605 this->ctm(), &grPaint)) {
1606 return;
1607 }
1608 }
1609
1610 fRenderTargetContext->drawAtlas(
1611 this->clip(), std::move(grPaint), this->ctm(), count, xform, texRect, colors);
1612}
1613
1614///////////////////////////////////////////////////////////////////////////////
1615
Herb Derbyb935cf82018-07-26 16:54:18 -04001616void SkGpuDevice::drawGlyphRunList(const SkGlyphRunList& glyphRunList) {
Herb Derbyb983e6b2018-07-13 13:26:29 -04001617 ASSERT_SINGLE_OWNER
1618 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawGlyphRunList", fContext.get());
Herb Derbyb983e6b2018-07-13 13:26:29 -04001619
Jim Van Verth87a30112018-09-24 16:13:58 -04001620 // Check for valid input
1621 const SkMatrix& ctm = this->ctm();
Mike Reed96345a22019-01-02 21:30:29 -05001622 if (!ctm.isFinite() || !glyphRunList.allFontsFinite()) {
Jim Van Verth87a30112018-09-24 16:13:58 -04001623 return;
1624 }
1625
1626 fRenderTargetContext->drawGlyphRunList(this->clip(), ctm, glyphRunList);
Herb Derbyb983e6b2018-07-13 13:26:29 -04001627}
1628
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001629///////////////////////////////////////////////////////////////////////////////
1630
Greg Daniel9ed1a2c2018-10-18 12:43:25 -04001631void SkGpuDevice::drawDrawable(SkDrawable* drawable, const SkMatrix* matrix, SkCanvas* canvas) {
Robert Phillips4217ea72019-01-30 13:08:28 -05001632 GrBackendApi api = this->context()->backend();
Greg Daniel9ed1a2c2018-10-18 12:43:25 -04001633 if (GrBackendApi::kVulkan == api) {
1634 const SkMatrix& ctm = canvas->getTotalMatrix();
1635 const SkMatrix& combinedMatrix = matrix ? SkMatrix::Concat(ctm, *matrix) : ctm;
1636 std::unique_ptr<SkDrawable::GpuDrawHandler> gpuDraw =
Derek Sollenbergere6fb76b2019-01-10 13:19:06 -05001637 drawable->snapGpuDrawHandler(api, combinedMatrix, canvas->getDeviceClipBounds(),
1638 this->imageInfo());
Greg Daniel9ed1a2c2018-10-18 12:43:25 -04001639 if (gpuDraw) {
Greg Daniel64cc9aa2018-10-19 13:54:56 -04001640 fRenderTargetContext->drawDrawable(std::move(gpuDraw), drawable->getBounds());
1641 return;
Greg Daniel9ed1a2c2018-10-18 12:43:25 -04001642 }
1643 }
1644 this->INHERITED::drawDrawable(drawable, matrix, canvas);
1645}
1646
Greg Daniel64cc9aa2018-10-19 13:54:56 -04001647
Greg Daniel9ed1a2c2018-10-18 12:43:25 -04001648///////////////////////////////////////////////////////////////////////////////
1649
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001650void SkGpuDevice::flush() {
Greg Daniele6bfb7d2019-04-17 15:26:11 -04001651 this->flush(SkSurface::BackendSurfaceAccess::kNoAccess, GrFlushInfo());
Greg Daniela5cb7812017-06-16 09:45:32 -04001652}
1653
Greg Daniele6bfb7d2019-04-17 15:26:11 -04001654GrSemaphoresSubmitted SkGpuDevice::flush(SkSurface::BackendSurfaceAccess access,
1655 const GrFlushInfo& info) {
joshualittce894002016-01-11 13:29:31 -08001656 ASSERT_SINGLE_OWNER
joshualittbc907352016-01-13 06:45:40 -08001657
Greg Daniele6bfb7d2019-04-17 15:26:11 -04001658 return fRenderTargetContext->flush(access, info);
Greg Daniela5cb7812017-06-16 09:45:32 -04001659}
1660
Greg Danielc64ee462017-06-15 16:59:49 -04001661bool SkGpuDevice::wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores) {
Greg Daniela5cb7812017-06-16 09:45:32 -04001662 ASSERT_SINGLE_OWNER
1663
Greg Danielc64ee462017-06-15 16:59:49 -04001664 return fRenderTargetContext->waitOnSemaphores(numSemaphores, waitSemaphores);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001665}
1666
1667///////////////////////////////////////////////////////////////////////////////
1668
reed76033be2015-03-14 10:54:31 -07001669SkBaseDevice* SkGpuDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint*) {
joshualittce894002016-01-11 13:29:31 -08001670 ASSERT_SINGLE_OWNER
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001671
robertphillipsca6eafc2016-05-17 09:57:46 -07001672 SkSurfaceProps props(this->surfaceProps().flags(), cinfo.fPixelGeometry);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001673
robertphillipsca6eafc2016-05-17 09:57:46 -07001674 // layers are never drawn in repeat modes, so we can request an approx
hcm4396fa52014-10-27 21:43:30 -07001675 // match and ignore any padding.
robertphillipsca6eafc2016-05-17 09:57:46 -07001676 SkBackingFit fit = kNever_TileUsage == cinfo.fTileUsage ? SkBackingFit::kApprox
1677 : SkBackingFit::kExact;
bsalomonafe30052015-01-16 07:32:33 -08001678
Brian Osman10fc6fd2018-03-02 11:01:10 -05001679 GrPixelConfig config = fRenderTargetContext->colorSpaceInfo().config();
Greg Daniel4065d452018-11-16 15:43:41 -05001680 const GrBackendFormat& origFormat = fRenderTargetContext->asSurfaceProxy()->backendFormat();
1681 GrBackendFormat format = origFormat.makeTexture2D();
1682 if (!format.isValid()) {
1683 return nullptr;
1684 }
Brian Osman10fc6fd2018-03-02 11:01:10 -05001685 if (kRGBA_1010102_GrPixelConfig == config) {
1686 // If the original device is 1010102, fall back to 8888 so that we have a usable alpha
1687 // channel in the layer.
1688 config = kRGBA_8888_GrPixelConfig;
Greg Daniel4065d452018-11-16 15:43:41 -05001689 format =
Robert Phillips9da87e02019-02-04 13:26:26 -05001690 fContext->priv().caps()->getBackendFormatFromColorType(kRGBA_8888_SkColorType);
Brian Osman10fc6fd2018-03-02 11:01:10 -05001691 }
1692
Robert Phillips9da87e02019-02-04 13:26:26 -05001693 sk_sp<GrRenderTargetContext> rtc(fContext->priv().makeDeferredRenderTargetContext(
Greg Daniel4065d452018-11-16 15:43:41 -05001694 format, fit, cinfo.fInfo.width(), cinfo.fInfo.height(), config,
Brian Salomonf3569f02017-10-24 12:52:33 -04001695 fRenderTargetContext->colorSpaceInfo().refColorSpace(),
Greg Daniel45d63032017-10-30 13:41:26 -04001696 fRenderTargetContext->numStencilSamples(), GrMipMapped::kNo,
1697 kBottomLeft_GrSurfaceOrigin, &props));
Brian Osman11052242016-10-27 14:47:55 -04001698 if (!rtc) {
Mike Kleine54c75f2016-10-13 14:18:09 -04001699 return nullptr;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001700 }
robertphillipsca6eafc2016-05-17 09:57:46 -07001701
1702 // Skia's convention is to only clear a device if it is non-opaque.
1703 InitContents init = cinfo.fInfo.isOpaque() ? kUninit_InitContents : kClear_InitContents;
1704
Robert Phillips9fab7e92016-11-17 12:45:04 -05001705 return SkGpuDevice::Make(fContext.get(), std::move(rtc),
1706 cinfo.fInfo.width(), cinfo.fInfo.height(), init).release();
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001707}
1708
reede8f30622016-03-23 18:59:25 -07001709sk_sp<SkSurface> SkGpuDevice::makeSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
joshualittce894002016-01-11 13:29:31 -08001710 ASSERT_SINGLE_OWNER
bsalomonafe30052015-01-16 07:32:33 -08001711 // TODO: Change the signature of newSurface to take a budgeted parameter.
bsalomon5ec26ae2016-02-25 08:33:02 -08001712 static const SkBudgeted kBudgeted = SkBudgeted::kNo;
Hal Canary144caf52016-11-07 17:57:18 -05001713 return SkSurface::MakeRenderTarget(fContext.get(), kBudgeted, info,
Brian Salomon50e66d42017-05-15 16:28:07 -04001714 fRenderTargetContext->numStencilSamples(),
Brian Osman11052242016-10-27 14:47:55 -04001715 fRenderTargetContext->origin(), &props);
reed@google.com76f10a32014-02-05 15:32:21 +00001716}
1717
senorblanco900c3672016-04-27 11:31:23 -07001718SkImageFilterCache* SkGpuDevice::getImageFilterCache() {
joshualittce894002016-01-11 13:29:31 -08001719 ASSERT_SINGLE_OWNER
senorblanco55b6d8b2014-07-30 11:26:46 -07001720 // We always return a transient cache, so it is freed after each
1721 // filter traversal.
brianosman04a44d02016-09-21 09:46:57 -07001722 return SkImageFilterCache::Create(SkImageFilterCache::kDefaultTransientSize);
senorblanco55b6d8b2014-07-30 11:26:46 -07001723}
reedf037e0b2014-10-30 11:34:15 -07001724