blob: 41257f01edbdcc946203327a9a92f44ac1e63cda [file] [log] [blame]
reed@google.comac10a2d2010-12-22 21:39:39 +00001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * Copyright 2010 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.
reed@google.comac10a2d2010-12-22 21:39:39 +00006 */
7
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "include/core/SkCanvas.h"
9#include "include/core/SkColorFilter.h"
10#include "include/core/SkData.h"
11#include "include/core/SkPixelRef.h"
12#include "include/gpu/GrContext.h"
13#include "include/gpu/GrTypes.h"
14#include "include/private/GrRecordingContext.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050015#include "include/private/SkImageInfoPriv.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050016#include "include/private/SkTemplates.h"
17#include "src/core/SkAutoMalloc.h"
18#include "src/core/SkBlendModePriv.h"
19#include "src/core/SkImagePriv.h"
20#include "src/core/SkMaskFilterBase.h"
Ben Wagner21bca282019-05-15 10:15:52 -040021#include "src/core/SkMessageBus.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050022#include "src/core/SkMipMap.h"
23#include "src/core/SkPaintPriv.h"
24#include "src/core/SkResourceCache.h"
25#include "src/core/SkTraceEvent.h"
26#include "src/gpu/GrBitmapTextureMaker.h"
27#include "src/gpu/GrCaps.h"
28#include "src/gpu/GrColorSpaceXform.h"
29#include "src/gpu/GrContextPriv.h"
30#include "src/gpu/GrGpuResourcePriv.h"
31#include "src/gpu/GrPaint.h"
32#include "src/gpu/GrProxyProvider.h"
33#include "src/gpu/GrRecordingContextPriv.h"
Greg Danielf91aeb22019-06-18 09:58:02 -040034#include "src/gpu/GrTextureProxy.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050035#include "src/gpu/GrXferProcessor.h"
36#include "src/gpu/SkGr.h"
37#include "src/gpu/effects/GrBicubicEffect.h"
38#include "src/gpu/effects/GrPorterDuffXferProcessor.h"
39#include "src/gpu/effects/GrSkSLFP.h"
40#include "src/gpu/effects/GrXfermodeFragmentProcessor.h"
41#include "src/gpu/effects/generated/GrConstColorProcessor.h"
42#include "src/image/SkImage_Base.h"
43#include "src/shaders/SkShaderBase.h"
Ethan Nicholas00543112018-07-31 09:44:36 -040044
Ethan Nicholas78aceb22018-08-31 16:13:58 -040045#if SK_SUPPORT_GPU
46GR_FP_SRC_STRING SKSL_DITHER_SRC = R"(
Ethan Nicholas00543112018-07-31 09:44:36 -040047// This controls the range of values added to color channels
48layout(key) in int rangeType;
49
Mike Reed8c31f2b2019-07-16 16:50:14 -040050void main(float x, float y, inout half4 color) {
Ethan Nicholas00543112018-07-31 09:44:36 -040051 half value;
52 half range;
53 @switch (rangeType) {
54 case 0:
55 range = 1.0 / 255.0;
56 break;
57 case 1:
58 range = 1.0 / 63.0;
59 break;
60 default:
61 // Experimentally this looks better than the expected value of 1/15.
62 range = 1.0 / 15.0;
63 break;
64 }
65 @if (sk_Caps.integerSupport) {
66 // This ordered-dither code is lifted from the cpu backend.
67 uint x = uint(x);
68 uint y = uint(y);
69 uint m = (y & 1) << 5 | (x & 1) << 4 |
70 (y & 2) << 2 | (x & 2) << 1 |
71 (y & 4) >> 1 | (x & 4) >> 2;
72 value = half(m) * 1.0 / 64.0 - 63.0 / 128.0;
73 } else {
74 // Simulate the integer effect used above using step/mod. For speed, simulates a 4x4
75 // dither pattern rather than an 8x8 one.
Mike Reed8c31f2b2019-07-16 16:50:14 -040076 half4 modValues = mod(half4(half(x), half(y), half(x), half(y)), half4(2.0, 2.0, 4.0, 4.0));
Ethan Nicholas00543112018-07-31 09:44:36 -040077 half4 stepValues = step(modValues, half4(1.0, 1.0, 2.0, 2.0));
78 value = dot(stepValues, half4(8.0 / 16.0, 4.0 / 16.0, 2.0 / 16.0, 1.0 / 16.0)) - 15.0 / 32.0;
79 }
80 // For each color channel, add the random offset to the channel value and then clamp
81 // between 0 and alpha to keep the color premultiplied.
82 color = half4(clamp(color.rgb + value * range, 0.0, color.a), color.a);
83}
84)";
Ethan Nicholas78aceb22018-08-31 16:13:58 -040085#endif
krajcevski9c0e6292014-06-02 07:38:14 -070086
Brian Osman2b23c4b2018-06-01 12:25:08 -040087GrSurfaceDesc GrImageInfoToSurfaceDesc(const SkImageInfo& info) {
bsalomon466c2c42015-10-16 12:01:18 -070088 GrSurfaceDesc desc;
bsalomon466c2c42015-10-16 12:01:18 -070089 desc.fWidth = info.width();
90 desc.fHeight = info.height();
Brian Osman2b23c4b2018-06-01 12:25:08 -040091 desc.fConfig = SkImageInfo2GrPixelConfig(info);
bsalomon466c2c42015-10-16 12:01:18 -070092 return desc;
93}
94
bsalomon045802d2015-10-20 07:58:01 -070095void GrMakeKeyFromImageID(GrUniqueKey* key, uint32_t imageID, const SkIRect& imageBounds) {
96 SkASSERT(key);
97 SkASSERT(imageID);
98 SkASSERT(!imageBounds.isEmpty());
99 static const GrUniqueKey::Domain kImageIDDomain = GrUniqueKey::GenerateDomain();
Derek Sollenbergercf6da8c2018-03-29 13:40:02 -0400100 GrUniqueKey::Builder builder(key, kImageIDDomain, 5, "Image");
bsalomon466c2c42015-10-16 12:01:18 -0700101 builder[0] = imageID;
bsalomon045802d2015-10-20 07:58:01 -0700102 builder[1] = imageBounds.fLeft;
103 builder[2] = imageBounds.fTop;
104 builder[3] = imageBounds.fRight;
105 builder[4] = imageBounds.fBottom;
bsalomon466c2c42015-10-16 12:01:18 -0700106}
107
bsalomon045802d2015-10-20 07:58:01 -0700108////////////////////////////////////////////////////////////////////////////////
109
Brian Salomon238069b2018-07-11 15:58:57 -0400110void GrInstallBitmapUniqueKeyInvalidator(const GrUniqueKey& key, uint32_t contextUniqueID,
111 SkPixelRef* pixelRef) {
bsalomon89fe56b2015-10-29 10:49:28 -0700112 class Invalidator : public SkPixelRef::GenIDChangeListener {
113 public:
Brian Salomon238069b2018-07-11 15:58:57 -0400114 explicit Invalidator(const GrUniqueKey& key, uint32_t contextUniqueID)
115 : fMsg(key, contextUniqueID) {}
116
bsalomon89fe56b2015-10-29 10:49:28 -0700117 private:
118 GrUniqueKeyInvalidatedMessage fMsg;
119
120 void onChange() override { SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(fMsg); }
121 };
122
Brian Salomon238069b2018-07-11 15:58:57 -0400123 pixelRef->addGenIDChangeListener(new Invalidator(key, contextUniqueID));
bsalomon89fe56b2015-10-29 10:49:28 -0700124}
125
Robert Phillips9338c602019-02-19 12:52:29 -0500126sk_sp<GrTextureProxy> GrCopyBaseMipMapToTextureProxy(GrRecordingContext* ctx,
127 GrTextureProxy* baseProxy) {
Greg Daniel55afd6d2017-09-29 09:32:44 -0400128 SkASSERT(baseProxy);
129
Greg Daniel6980c4e2019-07-30 16:18:18 -0400130 if (!ctx->priv().caps()->isFormatCopyable(baseProxy->backendFormat())) {
Greg Danielbb76ace2017-09-29 15:58:22 -0400131 return nullptr;
132 }
Greg Daniel46cfbc62019-06-07 11:43:30 -0400133 return GrSurfaceProxy::Copy(ctx, baseProxy, GrMipMapped::kYes, SkBackingFit::kExact,
134 SkBudgeted::kYes);
Greg Daniel55afd6d2017-09-29 09:32:44 -0400135}
136
Robert Phillips9338c602019-02-19 12:52:29 -0500137sk_sp<GrTextureProxy> GrRefCachedBitmapTextureProxy(GrRecordingContext* ctx,
Robert Phillipsbbd7a3b2017-03-21 08:48:40 -0400138 const SkBitmap& bitmap,
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400139 const GrSamplerState& params,
Robert Phillipsbbd7a3b2017-03-21 08:48:40 -0400140 SkScalar scaleAdjust[2]) {
Brian Osman6064e1c2018-10-19 14:27:54 -0400141 return GrBitmapTextureMaker(ctx, bitmap).refTextureProxyForParams(params, scaleAdjust);
Robert Phillipsbbd7a3b2017-03-21 08:48:40 -0400142}
143
Robert Phillips1afd4cd2018-01-08 13:40:32 -0500144sk_sp<GrTextureProxy> GrMakeCachedBitmapProxy(GrProxyProvider* proxyProvider,
Greg Daniel7e1912a2018-02-08 09:15:33 -0500145 const SkBitmap& bitmap,
146 SkBackingFit fit) {
147 if (!bitmap.peekPixels(nullptr)) {
148 return nullptr;
Robert Phillipse14d3052017-02-15 13:18:21 -0500149 }
150
Greg Daniel7e1912a2018-02-08 09:15:33 -0500151 // In non-ddl we will always instantiate right away. Thus we never want to copy the SkBitmap
152 // even if its mutable. In ddl, if the bitmap is mutable then we must make a copy since the
153 // upload of the data to the gpu can happen at anytime and the bitmap may change by then.
Robert Phillipsa41c6852019-02-07 10:44:10 -0500154 SkCopyPixelsMode cpyMode = proxyProvider->renderingDirectly() ? kNever_SkCopyPixelsMode
155 : kIfMutable_SkCopyPixelsMode;
Greg Daniel7e1912a2018-02-08 09:15:33 -0500156 sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, cpyMode);
Robert Phillipse14d3052017-02-15 13:18:21 -0500157
Greg Daniel7e1912a2018-02-08 09:15:33 -0500158 if (!image) {
159 return nullptr;
Robert Phillipse14d3052017-02-15 13:18:21 -0500160 }
161
Greg Daniel7e1912a2018-02-08 09:15:33 -0500162 return GrMakeCachedImageProxy(proxyProvider, std::move(image), fit);
Robert Phillipse14d3052017-02-15 13:18:21 -0500163}
164
Robert Phillips7a926392018-02-01 15:49:54 -0500165static void create_unique_key_for_image(const SkImage* image, GrUniqueKey* result) {
166 if (!image) {
167 result->reset(); // will be invalid
168 return;
169 }
170
171 if (const SkBitmap* bm = as_IB(image)->onPeekBitmap()) {
Greg Daniela4211122018-03-14 19:09:36 +0000172 if (!bm->isVolatile()) {
173 SkIPoint origin = bm->pixelRefOrigin();
174 SkIRect subset = SkIRect::MakeXYWH(origin.fX, origin.fY, bm->width(), bm->height());
175 GrMakeKeyFromImageID(result, bm->getGenerationID(), subset);
176 }
Robert Phillips7a926392018-02-01 15:49:54 -0500177 return;
178 }
179
180 GrMakeKeyFromImageID(result, image->uniqueID(), image->bounds());
181}
182
183sk_sp<GrTextureProxy> GrMakeCachedImageProxy(GrProxyProvider* proxyProvider,
Greg Daniel490695b2018-02-05 09:34:02 -0500184 sk_sp<SkImage> srcImage,
185 SkBackingFit fit) {
Robert Phillips7a926392018-02-01 15:49:54 -0500186 sk_sp<GrTextureProxy> proxy;
187 GrUniqueKey originalKey;
188
189 create_unique_key_for_image(srcImage.get(), &originalKey);
190
191 if (originalKey.isValid()) {
Brian Salomon2af3e702019-08-11 19:10:31 -0400192 proxy = proxyProvider->findOrCreateProxyByUniqueKey(
193 originalKey, SkColorTypeToGrColorType(srcImage->colorType()),
194 kTopLeft_GrSurfaceOrigin);
Robert Phillips7a926392018-02-01 15:49:54 -0500195 }
196 if (!proxy) {
Brian Salomon96b383a2019-08-13 16:55:41 -0400197 proxy = proxyProvider->createTextureProxy(srcImage, 1, SkBudgeted::kYes, fit);
Robert Phillips7a926392018-02-01 15:49:54 -0500198 if (proxy && originalKey.isValid()) {
199 proxyProvider->assignUniqueKeyToProxy(originalKey, proxy.get());
Robert Phillips5c4b33b2018-03-20 16:23:08 -0400200 const SkBitmap* bm = as_IB(srcImage.get())->onPeekBitmap();
201 // When recording DDLs we do not want to install change listeners because doing
202 // so isn't threadsafe.
Robert Phillipsa41c6852019-02-07 10:44:10 -0500203 if (bm && proxyProvider->renderingDirectly()) {
204 GrInstallBitmapUniqueKeyInvalidator(originalKey, proxyProvider->contextID(),
Brian Salomon238069b2018-07-11 15:58:57 -0400205 bm->pixelRef());
Greg Daniela4211122018-03-14 19:09:36 +0000206 }
Robert Phillips7a926392018-02-01 15:49:54 -0500207 }
208 }
209
210 return proxy;
211}
212
rileya@google.com24f3ad12012-07-18 21:47:40 +0000213///////////////////////////////////////////////////////////////////////////////
214
Brian Osmanf28e55d2018-10-03 16:35:54 -0400215SkPMColor4f SkColorToPMColor4f(SkColor c, const GrColorSpaceInfo& colorSpaceInfo) {
216 SkColor4f color = SkColor4f::FromColor(c);
217 if (auto* xform = colorSpaceInfo.colorSpaceXformFromSRGB()) {
218 color = xform->apply(color);
219 }
220 return color.premul();
221}
222
Brian Osman8fa7ab42019-03-18 10:22:42 -0400223SkColor4f SkColor4fPrepForDst(SkColor4f color, const GrColorSpaceInfo& colorSpaceInfo) {
Brian Osman5c8a6b32018-11-19 11:56:57 -0500224 if (auto* xform = colorSpaceInfo.colorSpaceXformFromSRGB()) {
225 color = xform->apply(color);
226 }
Brian Osman5c8a6b32018-11-19 11:56:57 -0500227 return color;
228}
229
Brian Osmanc68d4aa2016-09-30 11:41:59 -0400230///////////////////////////////////////////////////////////////////////////////
231
Brian Osman2b23c4b2018-06-01 12:25:08 -0400232GrPixelConfig SkColorType2GrPixelConfig(const SkColorType type) {
Greg Daniel81e7bf82017-07-19 14:47:42 -0400233 switch (type) {
brianosmanc571c002016-03-17 13:01:26 -0700234 case kUnknown_SkColorType:
235 return kUnknown_GrPixelConfig;
236 case kAlpha_8_SkColorType:
237 return kAlpha_8_GrPixelConfig;
238 case kRGB_565_SkColorType:
239 return kRGB_565_GrPixelConfig;
240 case kARGB_4444_SkColorType:
241 return kRGBA_4444_GrPixelConfig;
242 case kRGBA_8888_SkColorType:
Brian Osman2b23c4b2018-06-01 12:25:08 -0400243 return kRGBA_8888_GrPixelConfig;
Brian Salomone41e1762018-01-25 14:07:47 -0500244 case kRGB_888x_SkColorType:
Brian Salomon5fba7ad2018-03-22 10:01:16 -0400245 return kRGB_888_GrPixelConfig;
brianosmanc571c002016-03-17 13:01:26 -0700246 case kBGRA_8888_SkColorType:
Brian Osman2b23c4b2018-06-01 12:25:08 -0400247 return kBGRA_8888_GrPixelConfig;
Brian Salomone41e1762018-01-25 14:07:47 -0500248 case kRGBA_1010102_SkColorType:
Brian Osman10fc6fd2018-03-02 11:01:10 -0500249 return kRGBA_1010102_GrPixelConfig;
Brian Salomone41e1762018-01-25 14:07:47 -0500250 case kRGB_101010x_SkColorType:
251 return kUnknown_GrPixelConfig;
brianosmanc571c002016-03-17 13:01:26 -0700252 case kGray_8_SkColorType:
Brian Osman986563b2017-01-10 14:20:02 -0500253 return kGray_8_GrPixelConfig;
Brian Osmand0626aa2019-03-11 15:28:06 -0400254 case kRGBA_F16Norm_SkColorType:
255 return kRGBA_half_Clamped_GrPixelConfig;
brianosmanc571c002016-03-17 13:01:26 -0700256 case kRGBA_F16_SkColorType:
257 return kRGBA_half_GrPixelConfig;
Mike Klein37854712018-06-26 11:43:06 -0400258 case kRGBA_F32_SkColorType:
259 return kRGBA_float_GrPixelConfig;
Robert Phillipsd470e1b2019-09-04 15:05:35 -0400260 case kRG_88_SkColorType:
261 return kRG_88_GrPixelConfig;
Robert Phillips429f0d32019-09-11 17:03:28 -0400262 case kRG_1616_SkColorType:
263 return kRG_1616_GrPixelConfig;
264 case kAlpha_16_SkColorType:
265 return kAlpha_16_GrPixelConfig;
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000266 }
267 SkASSERT(0); // shouldn't get here
268 return kUnknown_GrPixelConfig;
269}
270
Brian Osman2b23c4b2018-06-01 12:25:08 -0400271GrPixelConfig SkImageInfo2GrPixelConfig(const SkImageInfo& info) {
272 return SkColorType2GrPixelConfig(info.colorType());
Greg Daniel81e7bf82017-07-19 14:47:42 -0400273}
274
brianosman396fcdb2016-07-22 06:26:11 -0700275bool GrPixelConfigToColorType(GrPixelConfig config, SkColorType* ctOut) {
Brian Salomon5fba7ad2018-03-22 10:01:16 -0400276 SkColorType ct = GrColorTypeToSkColorType(GrPixelConfigToColorType(config));
277 if (kUnknown_SkColorType != ct) {
278 if (ctOut) {
279 *ctOut = ct;
280 }
281 return true;
reed@google.combf790232013-12-13 19:45:58 +0000282 }
Brian Salomon5fba7ad2018-03-22 10:01:16 -0400283 return false;
reed@google.combf790232013-12-13 19:45:58 +0000284}
commit-bot@chromium.org8dcff642014-05-15 20:32:48 +0000285
bsalomonf1b7a1d2015-09-28 06:26:28 -0700286////////////////////////////////////////////////////////////////////////////////////////////////
commit-bot@chromium.org8dcff642014-05-15 20:32:48 +0000287
Mike Reed185ba212017-04-28 12:31:05 -0400288static inline bool blend_requires_shader(const SkBlendMode mode) {
289 return SkBlendMode::kDst != mode;
bsalomonaa48d362015-10-01 08:34:17 -0700290}
291
Ethan Nicholas00543112018-07-31 09:44:36 -0400292#ifndef SK_IGNORE_GPU_DITHER
Brian Salomonbd3d8d32019-07-02 09:16:28 -0400293static inline int32_t dither_range_type_for_config(GrColorType dstColorType) {
294 switch (dstColorType) {
295 case GrColorType::kGray_8:
296 case GrColorType::kRGBA_8888:
297 case GrColorType::kRGB_888x:
298 case GrColorType::kRG_88:
299 case GrColorType::kBGRA_8888:
Brian Salomonbd3d8d32019-07-02 09:16:28 -0400300 case GrColorType::kRG_1616:
Robert Phillips66a46032019-06-18 08:00:42 -0400301 // Experimental (for Y416 and mutant P016/P010)
Brian Salomonbd3d8d32019-07-02 09:16:28 -0400302 case GrColorType::kRGBA_16161616:
303 case GrColorType::kRG_F16:
Ethan Nicholas00543112018-07-31 09:44:36 -0400304 return 0;
Brian Salomonbd3d8d32019-07-02 09:16:28 -0400305 case GrColorType::kBGR_565:
Ethan Nicholas00543112018-07-31 09:44:36 -0400306 return 1;
Brian Salomonbd3d8d32019-07-02 09:16:28 -0400307 case GrColorType::kABGR_4444:
Ethan Nicholas00543112018-07-31 09:44:36 -0400308 return 2;
Brian Salomonbd3d8d32019-07-02 09:16:28 -0400309 case GrColorType::kUnknown:
Greg Daniele877dce2019-07-11 10:52:43 -0400310 case GrColorType::kRGBA_8888_SRGB:
Brian Salomonbd3d8d32019-07-02 09:16:28 -0400311 case GrColorType::kRGBA_1010102:
312 case GrColorType::kAlpha_F16:
313 case GrColorType::kRGBA_F32:
Brian Salomonbd3d8d32019-07-02 09:16:28 -0400314 case GrColorType::kRGBA_F16:
315 case GrColorType::kRGBA_F16_Clamped:
316 case GrColorType::kAlpha_8:
Brian Salomon8f8354a2019-07-31 20:12:02 -0400317 case GrColorType::kAlpha_8xxx:
Robert Phillips429f0d32019-09-11 17:03:28 -0400318 case GrColorType::kAlpha_16:
Brian Salomon8f8354a2019-07-31 20:12:02 -0400319 case GrColorType::kAlpha_F32xxx:
320 case GrColorType::kGray_8xxx:
Ethan Nicholas00543112018-07-31 09:44:36 -0400321 return -1;
322 }
Brian Salomonbd3d8d32019-07-02 09:16:28 -0400323 SkUNREACHABLE;
Ethan Nicholas00543112018-07-31 09:44:36 -0400324}
325#endif
326
Robert Phillips9338c602019-02-19 12:52:29 -0500327static inline bool skpaint_to_grpaint_impl(GrRecordingContext* context,
Brian Salomonf3569f02017-10-24 12:52:33 -0400328 const GrColorSpaceInfo& colorSpaceInfo,
bsalomonf1b7a1d2015-09-28 06:26:28 -0700329 const SkPaint& skPaint,
330 const SkMatrix& viewM,
Brian Salomonaff329b2017-08-11 09:40:37 -0400331 std::unique_ptr<GrFragmentProcessor>* shaderProcessor,
Mike Reed7d954ad2016-10-28 15:42:34 -0400332 SkBlendMode* primColorMode,
bsalomonf1b7a1d2015-09-28 06:26:28 -0700333 GrPaint* grPaint) {
Brian Osman08a50e02018-06-15 15:06:48 -0400334 // Convert SkPaint color to 4f format in the destination color space
Brian Osman8fa7ab42019-03-18 10:22:42 -0400335 SkColor4f origColor = SkColor4fPrepForDst(skPaint.getColor4f(), colorSpaceInfo);
brianosmana4535a32016-06-24 12:50:19 -0700336
Brian Salomonc0d79e52019-04-10 15:02:11 -0400337 GrFPArgs fpArgs(context, &viewM, skPaint.getFilterQuality(), &colorSpaceInfo);
Mike Reedbfadcf02018-01-20 22:24:21 +0000338
bsalomonf1b7a1d2015-09-28 06:26:28 -0700339 // Setup the initial color considering the shader, the SkPaint color, and the presence or not
340 // of per-vertex colors.
Brian Salomonaff329b2017-08-11 09:40:37 -0400341 std::unique_ptr<GrFragmentProcessor> shaderFP;
Mike Reed185ba212017-04-28 12:31:05 -0400342 if (!primColorMode || blend_requires_shader(*primColorMode)) {
Brian Salomonc0d79e52019-04-10 15:02:11 -0400343 fpArgs.fInputColorIsOpaque = origColor.isOpaque();
bsalomonaa48d362015-10-01 08:34:17 -0700344 if (shaderProcessor) {
Brian Salomonaff329b2017-08-11 09:40:37 -0400345 shaderFP = std::move(*shaderProcessor);
Florin Malita4aed1382017-05-25 10:38:07 -0400346 } else if (const auto* shader = as_SB(skPaint.getShader())) {
Mike Reedbfadcf02018-01-20 22:24:21 +0000347 shaderFP = shader->asFragmentProcessor(fpArgs);
Yuqian Liaad2ec62018-02-26 10:34:52 -0500348 if (!shaderFP) {
349 return false;
350 }
bsalomonf1b7a1d2015-09-28 06:26:28 -0700351 }
352 }
353
354 // Set this in below cases if the output of the shader/paint-color/paint-alpha/primXfermode is
355 // a known constant value. In that case we can simply apply a color filter during this
356 // conversion without converting the color filter to a GrFragmentProcessor.
357 bool applyColorFilterToPaintColor = false;
358 if (shaderFP) {
359 if (primColorMode) {
360 // There is a blend between the primitive color and the shader color. The shader sees
361 // the opaque paint color. The shader's output is blended using the provided mode by
362 // the primitive color. The blended color is then modulated by the paint's alpha.
363
364 // The geometry processor will insert the primitive color to start the color chain, so
365 // the GrPaint color will be ignored.
366
Brian Osmancb3d0872018-10-16 15:19:28 -0400367 SkPMColor4f shaderInput = origColor.makeOpaque().premul();
Brian Salomonaff329b2017-08-11 09:40:37 -0400368 shaderFP = GrFragmentProcessor::OverrideInput(std::move(shaderFP), shaderInput);
Mike Reed185ba212017-04-28 12:31:05 -0400369 shaderFP = GrXfermodeFragmentProcessor::MakeFromSrcProcessor(std::move(shaderFP),
370 *primColorMode);
371
bsalomonf1b7a1d2015-09-28 06:26:28 -0700372 // The above may return null if compose results in a pass through of the prim color.
373 if (shaderFP) {
Robert Phillips1c9686b2017-06-30 08:40:28 -0400374 grPaint->addColorFragmentProcessor(std::move(shaderFP));
bsalomonf1b7a1d2015-09-28 06:26:28 -0700375 }
376
brianosmana4535a32016-06-24 12:50:19 -0700377 // We can ignore origColor here - alpha is unchanged by gamma
Brian Osman00b29392018-11-05 15:42:43 -0500378 float paintAlpha = skPaint.getColor4f().fA;
379 if (1.0f != paintAlpha) {
Brian Osman618d3042016-10-25 10:51:28 -0400380 // No gamut conversion - paintAlpha is a (linear) alpha value, splatted to all
381 // color channels. It's value should be treated as the same in ANY color space.
bungeman06ca8ec2016-06-09 08:01:03 -0700382 grPaint->addColorFragmentProcessor(GrConstColorProcessor::Make(
Brian Osman00b29392018-11-05 15:42:43 -0500383 { paintAlpha, paintAlpha, paintAlpha, paintAlpha },
Ethan Nicholase9d172a2017-11-20 12:12:24 -0500384 GrConstColorProcessor::InputMode::kModulateRGBA));
bsalomonf1b7a1d2015-09-28 06:26:28 -0700385 }
386 } else {
Brian Osmancb3d0872018-10-16 15:19:28 -0400387 // The shader's FP sees the paint *unpremul* color
388 SkPMColor4f origColorAsPM = { origColor.fR, origColor.fG, origColor.fB, origColor.fA };
389 grPaint->setColor4f(origColorAsPM);
bungeman06ca8ec2016-06-09 08:01:03 -0700390 grPaint->addColorFragmentProcessor(std::move(shaderFP));
bsalomonf1b7a1d2015-09-28 06:26:28 -0700391 }
392 } else {
393 if (primColorMode) {
394 // There is a blend between the primitive color and the paint color. The blend considers
395 // the opaque paint color. The paint's alpha is applied to the post-blended color.
Brian Osmancb3d0872018-10-16 15:19:28 -0400396 SkPMColor4f opaqueColor = origColor.makeOpaque().premul();
397 auto processor = GrConstColorProcessor::Make(opaqueColor,
398 GrConstColorProcessor::InputMode::kIgnore);
Mike Reed185ba212017-04-28 12:31:05 -0400399 processor = GrXfermodeFragmentProcessor::MakeFromSrcProcessor(std::move(processor),
400 *primColorMode);
bsalomonf1b7a1d2015-09-28 06:26:28 -0700401 if (processor) {
bungeman06ca8ec2016-06-09 08:01:03 -0700402 grPaint->addColorFragmentProcessor(std::move(processor));
bsalomonf1b7a1d2015-09-28 06:26:28 -0700403 }
404
Brian Osmancb3d0872018-10-16 15:19:28 -0400405 grPaint->setColor4f(opaqueColor);
bsalomonf1b7a1d2015-09-28 06:26:28 -0700406
brianosmana4535a32016-06-24 12:50:19 -0700407 // We can ignore origColor here - alpha is unchanged by gamma
Brian Osman00b29392018-11-05 15:42:43 -0500408 float paintAlpha = skPaint.getColor4f().fA;
409 if (1.0f != paintAlpha) {
Brian Osman618d3042016-10-25 10:51:28 -0400410 // No gamut conversion - paintAlpha is a (linear) alpha value, splatted to all
411 // color channels. It's value should be treated as the same in ANY color space.
bungeman06ca8ec2016-06-09 08:01:03 -0700412 grPaint->addColorFragmentProcessor(GrConstColorProcessor::Make(
Brian Osman00b29392018-11-05 15:42:43 -0500413 { paintAlpha, paintAlpha, paintAlpha, paintAlpha },
Ethan Nicholase9d172a2017-11-20 12:12:24 -0500414 GrConstColorProcessor::InputMode::kModulateRGBA));
bsalomonaa48d362015-10-01 08:34:17 -0700415 }
bsalomonf1b7a1d2015-09-28 06:26:28 -0700416 } else {
417 // No shader, no primitive color.
brianosmana4535a32016-06-24 12:50:19 -0700418 grPaint->setColor4f(origColor.premul());
bsalomonf1b7a1d2015-09-28 06:26:28 -0700419 applyColorFilterToPaintColor = true;
420 }
421 }
422
423 SkColorFilter* colorFilter = skPaint.getColorFilter();
424 if (colorFilter) {
425 if (applyColorFilterToPaintColor) {
Brian Osmancb3d0872018-10-16 15:19:28 -0400426 grPaint->setColor4f(
427 colorFilter->filterColor4f(origColor, colorSpaceInfo.colorSpace()).premul());
bsalomonf1b7a1d2015-09-28 06:26:28 -0700428 } else {
Brian Salomon4cbb6e62017-10-25 15:12:19 -0400429 auto cfFP = colorFilter->asFragmentProcessor(context, colorSpaceInfo);
bsalomone25eea42015-09-29 06:38:55 -0700430 if (cfFP) {
bungeman06ca8ec2016-06-09 08:01:03 -0700431 grPaint->addColorFragmentProcessor(std::move(cfFP));
bsalomonf1b7a1d2015-09-28 06:26:28 -0700432 } else {
433 return false;
434 }
435 }
436 }
437
Mike Reed80747ef2018-01-23 15:29:32 -0500438 SkMaskFilterBase* maskFilter = as_MFB(skPaint.getMaskFilter());
Robert Phillipsa29a9562016-10-20 09:40:55 -0400439 if (maskFilter) {
Brian Salomonc0d79e52019-04-10 15:02:11 -0400440 // We may have set this before passing to the SkShader.
441 fpArgs.fInputColorIsOpaque = false;
Mike Reedbfadcf02018-01-20 22:24:21 +0000442 if (auto mfFP = maskFilter->asFragmentProcessor(fpArgs)) {
443 grPaint->addCoverageFragmentProcessor(std::move(mfFP));
Robert Phillipsa29a9562016-10-20 09:40:55 -0400444 }
445 }
446
robertphillips4f037942016-02-09 05:09:27 -0800447 // When the xfermode is null on the SkPaint (meaning kSrcOver) we need the XPFactory field on
448 // the GrPaint to also be null (also kSrcOver).
449 SkASSERT(!grPaint->getXPFactory());
reed374772b2016-10-05 17:33:02 -0700450 if (!skPaint.isSrcOver()) {
451 grPaint->setXPFactory(SkBlendMode_AsXPFactory(skPaint.getBlendMode()));
robertphillips4f037942016-02-09 05:09:27 -0800452 }
mtklein775b8192014-12-02 09:11:25 -0800453
krajcevskif461a8f2014-06-19 14:14:06 -0700454#ifndef SK_IGNORE_GPU_DITHER
Florin Malitad4a70ee2017-06-19 10:21:43 -0400455 // Conservative default, in case GrPixelConfigToColorType() fails.
Brian Salomonbd3d8d32019-07-02 09:16:28 -0400456 GrColorType ct = colorSpaceInfo.colorType();
457 if (SkPaintPriv::ShouldDither(skPaint, GrColorTypeToSkColorType(ct)) &&
458 grPaint->numColorFragmentProcessors() > 0) {
459 int32_t ditherRange = dither_range_type_for_config(ct);
Ethan Nicholas00543112018-07-31 09:44:36 -0400460 if (ditherRange >= 0) {
461 static int ditherIndex = GrSkSLFP::NewIndex();
462 auto ditherFP = GrSkSLFP::Make(context, ditherIndex, "Dither", SKSL_DITHER_SRC,
Ethan Nicholaseace9352018-10-15 20:09:54 +0000463 &ditherRange, sizeof(ditherRange));
Ethan Nicholas00543112018-07-31 09:44:36 -0400464 if (ditherFP) {
465 grPaint->addColorFragmentProcessor(std::move(ditherFP));
466 }
Brian Salomon0c15ae82017-07-19 15:39:56 +0000467 }
krajcevskif461a8f2014-06-19 14:14:06 -0700468 }
469#endif
bsalomonbed83a62015-04-15 14:18:34 -0700470 return true;
commit-bot@chromium.org8dcff642014-05-15 20:32:48 +0000471}
472
Robert Phillips9338c602019-02-19 12:52:29 -0500473bool SkPaintToGrPaint(GrRecordingContext* context, const GrColorSpaceInfo& colorSpaceInfo,
Brian Salomonf3569f02017-10-24 12:52:33 -0400474 const SkPaint& skPaint, const SkMatrix& viewM, GrPaint* grPaint) {
475 return skpaint_to_grpaint_impl(context, colorSpaceInfo, skPaint, viewM, nullptr, nullptr,
476 grPaint);
bsalomonf1b7a1d2015-09-28 06:26:28 -0700477}
commit-bot@chromium.org8dcff642014-05-15 20:32:48 +0000478
bsalomonf1b7a1d2015-09-28 06:26:28 -0700479/** Replaces the SkShader (if any) on skPaint with the passed in GrFragmentProcessor. */
Robert Phillips9338c602019-02-19 12:52:29 -0500480bool SkPaintToGrPaintReplaceShader(GrRecordingContext* context,
Brian Salomonf3569f02017-10-24 12:52:33 -0400481 const GrColorSpaceInfo& colorSpaceInfo,
bsalomonf1b7a1d2015-09-28 06:26:28 -0700482 const SkPaint& skPaint,
Brian Salomonaff329b2017-08-11 09:40:37 -0400483 std::unique_ptr<GrFragmentProcessor> shaderFP,
bsalomonf1b7a1d2015-09-28 06:26:28 -0700484 GrPaint* grPaint) {
485 if (!shaderFP) {
bsalomonc21b09e2015-08-28 18:46:56 -0700486 return false;
commit-bot@chromium.org8dcff642014-05-15 20:32:48 +0000487 }
Brian Salomonf3569f02017-10-24 12:52:33 -0400488 return skpaint_to_grpaint_impl(context, colorSpaceInfo, skPaint, SkMatrix::I(), &shaderFP,
489 nullptr, grPaint);
commit-bot@chromium.org8dcff642014-05-15 20:32:48 +0000490}
reed8b26b992015-05-07 15:36:17 -0700491
bsalomonf1b7a1d2015-09-28 06:26:28 -0700492/** Ignores the SkShader (if any) on skPaint. */
Robert Phillips9338c602019-02-19 12:52:29 -0500493bool SkPaintToGrPaintNoShader(GrRecordingContext* context,
Brian Salomonf3569f02017-10-24 12:52:33 -0400494 const GrColorSpaceInfo& colorSpaceInfo,
bsalomonf1b7a1d2015-09-28 06:26:28 -0700495 const SkPaint& skPaint,
496 GrPaint* grPaint) {
497 // Use a ptr to a nullptr to to indicate that the SkShader is ignored and not replaced.
Robert Phillipsd3b37a12018-03-27 09:53:35 -0400498 std::unique_ptr<GrFragmentProcessor> nullShaderFP(nullptr);
499 return skpaint_to_grpaint_impl(context, colorSpaceInfo, skPaint, SkMatrix::I(), &nullShaderFP,
Brian Salomonf3569f02017-10-24 12:52:33 -0400500 nullptr, grPaint);
bsalomonf1b7a1d2015-09-28 06:26:28 -0700501}
502
503/** Blends the SkPaint's shader (or color if no shader) with a per-primitive color which must
Mike Reed7d954ad2016-10-28 15:42:34 -0400504be setup as a vertex attribute using the specified SkBlendMode. */
Robert Phillips9338c602019-02-19 12:52:29 -0500505bool SkPaintToGrPaintWithXfermode(GrRecordingContext* context,
Brian Salomonf3569f02017-10-24 12:52:33 -0400506 const GrColorSpaceInfo& colorSpaceInfo,
bsalomonf1b7a1d2015-09-28 06:26:28 -0700507 const SkPaint& skPaint,
508 const SkMatrix& viewM,
Mike Reed7d954ad2016-10-28 15:42:34 -0400509 SkBlendMode primColorMode,
bsalomonf1b7a1d2015-09-28 06:26:28 -0700510 GrPaint* grPaint) {
Brian Salomonf3569f02017-10-24 12:52:33 -0400511 return skpaint_to_grpaint_impl(context, colorSpaceInfo, skPaint, viewM, nullptr, &primColorMode,
Mike Reed185ba212017-04-28 12:31:05 -0400512 grPaint);
bsalomonf1b7a1d2015-09-28 06:26:28 -0700513}
514
Robert Phillips9338c602019-02-19 12:52:29 -0500515bool SkPaintToGrPaintWithTexture(GrRecordingContext* context,
Brian Salomonf3569f02017-10-24 12:52:33 -0400516 const GrColorSpaceInfo& colorSpaceInfo,
joshualitt33a5fce2015-11-18 13:28:51 -0800517 const SkPaint& paint,
518 const SkMatrix& viewM,
Brian Salomonaff329b2017-08-11 09:40:37 -0400519 std::unique_ptr<GrFragmentProcessor> fp,
joshualitt33a5fce2015-11-18 13:28:51 -0800520 bool textureIsAlphaOnly,
521 GrPaint* grPaint) {
Brian Salomonaff329b2017-08-11 09:40:37 -0400522 std::unique_ptr<GrFragmentProcessor> shaderFP;
joshualitt33a5fce2015-11-18 13:28:51 -0800523 if (textureIsAlphaOnly) {
Florin Malita4aed1382017-05-25 10:38:07 -0400524 if (const auto* shader = as_SB(paint.getShader())) {
Mike Reede3429e62018-01-19 11:43:34 -0500525 shaderFP = shader->asFragmentProcessor(GrFPArgs(
Florin Malitac6c5ead2018-04-11 15:33:40 -0400526 context, &viewM, paint.getFilterQuality(), &colorSpaceInfo));
joshualitt33a5fce2015-11-18 13:28:51 -0800527 if (!shaderFP) {
528 return false;
529 }
Brian Salomonaff329b2017-08-11 09:40:37 -0400530 std::unique_ptr<GrFragmentProcessor> fpSeries[] = { std::move(shaderFP), std::move(fp) };
bungeman06ca8ec2016-06-09 08:01:03 -0700531 shaderFP = GrFragmentProcessor::RunInSeries(fpSeries, 2);
joshualitt33a5fce2015-11-18 13:28:51 -0800532 } else {
Brian Salomonaff329b2017-08-11 09:40:37 -0400533 shaderFP = GrFragmentProcessor::MakeInputPremulAndMulByOutput(std::move(fp));
joshualitt33a5fce2015-11-18 13:28:51 -0800534 }
535 } else {
Brian Salomonc0d79e52019-04-10 15:02:11 -0400536 if (paint.getColor4f().isOpaque()) {
537 shaderFP = GrFragmentProcessor::OverrideInput(std::move(fp), SK_PMColor4fWHITE, false);
538 } else {
539 shaderFP = GrFragmentProcessor::MulChildByInputAlpha(std::move(fp));
540 }
joshualitt33a5fce2015-11-18 13:28:51 -0800541 }
542
Brian Salomonf3569f02017-10-24 12:52:33 -0400543 return SkPaintToGrPaintReplaceShader(context, colorSpaceInfo, paint, std::move(shaderFP),
544 grPaint);
joshualitt33a5fce2015-11-18 13:28:51 -0800545}
546
bsalomonf1b7a1d2015-09-28 06:26:28 -0700547
548////////////////////////////////////////////////////////////////////////////////////////////////
549
Chris Dalton309c6c02019-08-13 10:32:47 -0600550GrSamplerState::Filter GrSkFilterQualityToGrFilterMode(int imageWidth, int imageHeight,
551 SkFilterQuality paintFilterQuality,
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400552 const SkMatrix& viewM,
553 const SkMatrix& localM,
Brian Osmandb78cba2018-02-15 10:09:48 -0500554 bool sharpenMipmappedTextures,
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400555 bool* doBicubic) {
joshualitt9bc39542015-08-12 12:57:54 -0700556 *doBicubic = false;
Chris Dalton309c6c02019-08-13 10:32:47 -0600557 if (imageWidth <= 1 && imageHeight <= 1) {
558 return GrSamplerState::Filter::kNearest;
559 }
joshualitt9bc39542015-08-12 12:57:54 -0700560 switch (paintFilterQuality) {
561 case kNone_SkFilterQuality:
Chris Dalton309c6c02019-08-13 10:32:47 -0600562 return GrSamplerState::Filter::kNearest;
joshualitt9bc39542015-08-12 12:57:54 -0700563 case kLow_SkFilterQuality:
Chris Dalton309c6c02019-08-13 10:32:47 -0600564 return GrSamplerState::Filter::kBilerp;
joshualitt9bc39542015-08-12 12:57:54 -0700565 case kMedium_SkFilterQuality: {
566 SkMatrix matrix;
567 matrix.setConcat(viewM, localM);
Brian Osmandb78cba2018-02-15 10:09:48 -0500568 // With sharp mips, we bias lookups by -0.5. That means our final LOD is >= 0 until the
569 // computed LOD is >= 0.5. At what scale factor does a texture get an LOD of 0.5?
570 //
571 // Want: 0 = log2(1/s) - 0.5
572 // 0.5 = log2(1/s)
573 // 2^0.5 = 1/s
574 // 1/2^0.5 = s
575 // 2^0.5/2 = s
576 SkScalar mipScale = sharpenMipmappedTextures ? SK_ScalarRoot2Over2 : SK_Scalar1;
577 if (matrix.getMinScale() < mipScale) {
Chris Dalton309c6c02019-08-13 10:32:47 -0600578 return GrSamplerState::Filter::kMipMap;
joshualitt9bc39542015-08-12 12:57:54 -0700579 } else {
580 // Don't trigger MIP level generation unnecessarily.
Chris Dalton309c6c02019-08-13 10:32:47 -0600581 return GrSamplerState::Filter::kBilerp;
joshualitt9bc39542015-08-12 12:57:54 -0700582 }
joshualitt9bc39542015-08-12 12:57:54 -0700583 }
584 case kHigh_SkFilterQuality: {
585 SkMatrix matrix;
586 matrix.setConcat(viewM, localM);
Chris Dalton309c6c02019-08-13 10:32:47 -0600587 GrSamplerState::Filter textureFilterMode;
joshualitt9bc39542015-08-12 12:57:54 -0700588 *doBicubic = GrBicubicEffect::ShouldUseBicubic(matrix, &textureFilterMode);
Chris Dalton309c6c02019-08-13 10:32:47 -0600589 return textureFilterMode;
joshualitt9bc39542015-08-12 12:57:54 -0700590 }
joshualitt9bc39542015-08-12 12:57:54 -0700591 }
Chris Dalton309c6c02019-08-13 10:32:47 -0600592 SkUNREACHABLE;
joshualitt9bc39542015-08-12 12:57:54 -0700593}