blob: 7a6d9675382cea1f6d11d7fe9c0c88bca038f312 [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
8#include "SkGpuDevice.h"
9
robertphillipsccb1b572015-05-27 11:02:55 -070010#include "GrBlurUtils.h"
kkinnunenabcfab42015-02-22 22:53:44 -080011#include "GrContext.h"
herb11a7f7f2015-11-24 12:41:00 -080012#include "SkDraw.h"
kkinnunenabcfab42015-02-22 22:53:44 -080013#include "GrGpu.h"
14#include "GrGpuResourcePriv.h"
bsalomonc55271f2015-11-09 11:55:57 -080015#include "GrImageIDTextureAdjuster.h"
robertphillips98d709b2014-09-02 10:20:50 -070016#include "GrLayerHoister.h"
robertphillips274b4ba2014-09-04 07:24:18 -070017#include "GrRecordReplaceDraw.h"
egdanield58a0ba2014-06-11 10:30:05 -070018#include "GrStrokeInfo.h"
egdanielbbcb38d2014-06-19 10:19:29 -070019#include "GrTracing.h"
robertphillips30d78412014-11-24 09:49:17 -080020#include "SkCanvasPriv.h"
kkinnunenabcfab42015-02-22 22:53:44 -080021#include "SkErrorInternals.h"
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000022#include "SkGlyphCache.h"
kkinnunenabcfab42015-02-22 22:53:44 -080023#include "SkGrTexturePixelRef.h"
bsalomonf276ac52015-10-09 13:36:42 -070024#include "SkGr.h"
bsalomonf1b7a1d2015-09-28 06:26:28 -070025#include "SkGrPriv.h"
reeda85d4d02015-05-06 12:56:48 -070026#include "SkImage_Base.h"
bsalomon1cf6f9b2015-12-08 10:53:43 -080027#include "SkImageCacherator.h"
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000028#include "SkImageFilter.h"
robertphillips82365912014-11-12 09:32:34 -080029#include "SkLayerInfo.h"
commit-bot@chromium.org82139702014-03-10 22:53:20 +000030#include "SkMaskFilter.h"
joshualitt33a5fce2015-11-18 13:28:51 -080031#include "SkNinePatchIter.h"
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000032#include "SkPathEffect.h"
commit-bot@chromium.org145d1c02014-03-16 19:46:36 +000033#include "SkPicture.h"
robertphillipsdb539902014-07-01 08:47:04 -070034#include "SkPictureData.h"
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000035#include "SkRRect.h"
kkinnunenabcfab42015-02-22 22:53:44 -080036#include "SkRecord.h"
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000037#include "SkStroke.h"
reed@google.com76f10a32014-02-05 15:32:21 +000038#include "SkSurface.h"
kkinnunenabcfab42015-02-22 22:53:44 -080039#include "SkSurface_Gpu.h"
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +000040#include "SkTLazy.h"
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000041#include "SkUtils.h"
commit-bot@chromium.org559a8832014-05-30 10:08:22 +000042#include "SkVertState.h"
robertphillips320c9232014-07-29 06:07:19 -070043#include "SkXfermode.h"
joshualitta61c8172015-08-17 10:51:22 -070044#include "batches/GrRectBatchFactory.h"
kkinnunenabcfab42015-02-22 22:53:44 -080045#include "effects/GrBicubicEffect.h"
46#include "effects/GrDashingEffect.h"
47#include "effects/GrSimpleTextureEffect.h"
48#include "effects/GrTextureDomain.h"
joshualitt8e84a1e2016-02-16 11:09:25 -080049#include "text/GrTextUtils.h"
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000050
reedf037e0b2014-10-30 11:34:15 -070051#if SK_SUPPORT_GPU
52
joshualittce894002016-01-11 13:29:31 -080053#define ASSERT_SINGLE_OWNER \
54 SkDEBUGCODE(GrSingleOwner::AutoEnforce debug_SingleOwner(fContext->debugSingleOwner());)
55
senorblanco55b6d8b2014-07-30 11:26:46 -070056enum { kDefaultImageFilterCacheSize = 32 * 1024 * 1024 };
57
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000058#if 0
59 extern bool (*gShouldDrawProc)();
joshualitt5531d512014-12-17 15:50:11 -080060 #define CHECK_SHOULD_DRAW(draw) \
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000061 do { \
62 if (gShouldDrawProc && !gShouldDrawProc()) return; \
joshualitt5531d512014-12-17 15:50:11 -080063 this->prepareDraw(draw); \
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000064 } while (0)
65#else
joshualitt5531d512014-12-17 15:50:11 -080066 #define CHECK_SHOULD_DRAW(draw) this->prepareDraw(draw)
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000067#endif
68
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +000069///////////////////////////////////////////////////////////////////////////////
70
bsalomonbcf0a522014-10-08 08:40:09 -070071// Helper for turning a bitmap into a texture. If the bitmap is GrTexture backed this
72// just accesses the backing GrTexture. Otherwise, it creates a cached texture
73// representation and releases it in the destructor.
74class AutoBitmapTexture : public SkNoncopyable {
Brian Salomon9323b8b2014-10-07 15:07:38 -040075public:
bsalomonbcf0a522014-10-08 08:40:09 -070076 AutoBitmapTexture() {}
robertphillipsdbe60742014-09-30 06:54:17 -070077
bsalomonbcf0a522014-10-08 08:40:09 -070078 AutoBitmapTexture(GrContext* context,
79 const SkBitmap& bitmap,
bsalomonafa95e22015-10-12 10:39:46 -070080 const GrTextureParams& params,
bsalomonbcf0a522014-10-08 08:40:09 -070081 GrTexture** texture) {
Brian Salomon9323b8b2014-10-07 15:07:38 -040082 SkASSERT(texture);
bsalomonbcf0a522014-10-08 08:40:09 -070083 *texture = this->set(context, bitmap, params);
Brian Salomon9323b8b2014-10-07 15:07:38 -040084 }
85
bsalomonbcf0a522014-10-08 08:40:09 -070086 GrTexture* set(GrContext* context,
Brian Salomon9323b8b2014-10-07 15:07:38 -040087 const SkBitmap& bitmap,
bsalomonafa95e22015-10-12 10:39:46 -070088 const GrTextureParams& params) {
bsalomonbcf0a522014-10-08 08:40:09 -070089 // Either get the texture directly from the bitmap, or else use the cache and
90 // remember to unref it.
91 if (GrTexture* bmpTexture = bitmap.getTexture()) {
halcanary96fcdcc2015-08-27 07:41:13 -070092 fTexture.reset(nullptr);
bsalomonbcf0a522014-10-08 08:40:09 -070093 return bmpTexture;
94 } else {
95 fTexture.reset(GrRefCachedBitmapTexture(context, bitmap, params));
96 return fTexture.get();
Brian Salomon9323b8b2014-10-07 15:07:38 -040097 }
Brian Salomon9323b8b2014-10-07 15:07:38 -040098 }
99
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000100private:
bsalomonbcf0a522014-10-08 08:40:09 -0700101 SkAutoTUnref<GrTexture> fTexture;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000102};
103
104///////////////////////////////////////////////////////////////////////////////
105
bsalomon74f681d2015-06-23 14:38:48 -0700106/** Checks that the alpha type is legal and gets constructor flags. Returns false if device creation
107 should fail. */
108bool SkGpuDevice::CheckAlphaTypeAndGetFlags(
109 const SkImageInfo* info, SkGpuDevice::InitContents init, unsigned* flags) {
110 *flags = 0;
111 if (info) {
112 switch (info->alphaType()) {
113 case kPremul_SkAlphaType:
114 break;
115 case kOpaque_SkAlphaType:
116 *flags |= SkGpuDevice::kIsOpaque_Flag;
117 break;
118 default: // If it is unpremul or unknown don't try to render
119 return false;
120 }
121 }
122 if (kClear_InitContents == init) {
123 *flags |= kNeedClear_Flag;
124 }
125 return true;
126}
127
128SkGpuDevice* SkGpuDevice::Create(GrRenderTarget* rt, const SkSurfaceProps* props,
129 InitContents init) {
130 return SkGpuDevice::Create(rt, rt->width(), rt->height(), props, init);
senorblancod0d37ca2015-04-02 04:54:56 -0700131}
132
133SkGpuDevice* SkGpuDevice::Create(GrRenderTarget* rt, int width, int height,
bsalomon74f681d2015-06-23 14:38:48 -0700134 const SkSurfaceProps* props, InitContents init) {
bsalomonafe30052015-01-16 07:32:33 -0800135 if (!rt || rt->wasDestroyed()) {
halcanary96fcdcc2015-08-27 07:41:13 -0700136 return nullptr;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000137 }
bsalomon74f681d2015-06-23 14:38:48 -0700138 unsigned flags;
halcanary96fcdcc2015-08-27 07:41:13 -0700139 if (!CheckAlphaTypeAndGetFlags(nullptr, init, &flags)) {
140 return nullptr;
bsalomon74f681d2015-06-23 14:38:48 -0700141 }
halcanary385fe4d2015-08-26 13:07:48 -0700142 return new SkGpuDevice(rt, width, height, props, flags);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000143}
144
bsalomon5ec26ae2016-02-25 08:33:02 -0800145SkGpuDevice* SkGpuDevice::Create(GrContext* context, SkBudgeted budgeted,
bsalomon74f681d2015-06-23 14:38:48 -0700146 const SkImageInfo& info, int sampleCount,
erikchen9a1ed5d2016-02-10 16:32:34 -0800147 const SkSurfaceProps* props, InitContents init,
148 GrTextureStorageAllocator customAllocator) {
bsalomon74f681d2015-06-23 14:38:48 -0700149 unsigned flags;
150 if (!CheckAlphaTypeAndGetFlags(&info, init, &flags)) {
halcanary96fcdcc2015-08-27 07:41:13 -0700151 return nullptr;
bsalomon74f681d2015-06-23 14:38:48 -0700152 }
153
erikchen9a1ed5d2016-02-10 16:32:34 -0800154 SkAutoTUnref<GrRenderTarget> rt(CreateRenderTarget(
155 context, budgeted, info, sampleCount, customAllocator));
halcanary96fcdcc2015-08-27 07:41:13 -0700156 if (nullptr == rt) {
157 return nullptr;
bsalomon74f681d2015-06-23 14:38:48 -0700158 }
159
halcanary385fe4d2015-08-26 13:07:48 -0700160 return new SkGpuDevice(rt, info.width(), info.height(), props, flags);
bsalomon74f681d2015-06-23 14:38:48 -0700161}
162
senorblancod0d37ca2015-04-02 04:54:56 -0700163SkGpuDevice::SkGpuDevice(GrRenderTarget* rt, int width, int height,
164 const SkSurfaceProps* props, unsigned flags)
robertphillipsfcf78292015-06-19 11:49:52 -0700165 : INHERITED(SkSurfacePropsCopyOrDefault(props))
joshualitt06dd0a82016-01-08 06:32:31 -0800166 , fContext(SkRef(rt->getContext()))
167 , fRenderTarget(SkRef(rt)) {
bsalomon74f681d2015-06-23 14:38:48 -0700168 fOpaque = SkToBool(flags & kIsOpaque_Flag);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000169
bsalomon74f681d2015-06-23 14:38:48 -0700170 SkAlphaType at = fOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
171 SkImageInfo info = rt->surfacePriv().info(at).makeWH(width, height);
halcanary385fe4d2015-08-26 13:07:48 -0700172 SkPixelRef* pr = new SkGrPixelRef(info, rt);
bsalomonafbf2d62014-09-30 12:18:44 -0700173 fLegacyBitmap.setInfo(info);
reed89443ab2014-06-27 11:34:19 -0700174 fLegacyBitmap.setPixelRef(pr)->unref();
kkinnunenc6cb56f2014-06-24 00:12:27 -0700175
robertphillips77a2e522015-10-17 07:43:27 -0700176 fDrawContext.reset(this->context()->drawContext(rt, &this->surfaceProps()));
bsalomone63ffef2016-02-05 07:17:34 -0800177 if (flags & kNeedClear_Flag) {
178 this->clearAll();
179 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000180}
181
erikchen9a1ed5d2016-02-10 16:32:34 -0800182GrRenderTarget* SkGpuDevice::CreateRenderTarget(
bsalomon5ec26ae2016-02-25 08:33:02 -0800183 GrContext* context, SkBudgeted budgeted, const SkImageInfo& origInfo,
erikchen9a1ed5d2016-02-10 16:32:34 -0800184 int sampleCount, GrTextureStorageAllocator textureStorageAllocator) {
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000185 if (kUnknown_SkColorType == origInfo.colorType() ||
186 origInfo.width() < 0 || origInfo.height() < 0) {
halcanary96fcdcc2015-08-27 07:41:13 -0700187 return nullptr;
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000188 }
189
bsalomonafe30052015-01-16 07:32:33 -0800190 if (!context) {
halcanary96fcdcc2015-08-27 07:41:13 -0700191 return nullptr;
bsalomonafe30052015-01-16 07:32:33 -0800192 }
193
reede5ea5002014-09-03 11:54:58 -0700194 SkColorType ct = origInfo.colorType();
195 SkAlphaType at = origInfo.alphaType();
reede5ea5002014-09-03 11:54:58 -0700196 if (kRGB_565_SkColorType == ct) {
197 at = kOpaque_SkAlphaType; // force this setting
bsalomonafe30052015-01-16 07:32:33 -0800198 } else if (ct != kBGRA_8888_SkColorType && ct != kRGBA_8888_SkColorType) {
199 // Fall back from whatever ct was to default of kRGBA or kBGRA which is aliased as kN32
reede5ea5002014-09-03 11:54:58 -0700200 ct = kN32_SkColorType;
bsalomonafe30052015-01-16 07:32:33 -0800201 }
202 if (kOpaque_SkAlphaType != at) {
203 at = kPremul_SkAlphaType; // force this setting
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000204 }
reede5ea5002014-09-03 11:54:58 -0700205 const SkImageInfo info = SkImageInfo::Make(origInfo.width(), origInfo.height(), ct, at);
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000206
bsalomonf2703d82014-10-28 14:33:06 -0700207 GrSurfaceDesc desc;
208 desc.fFlags = kRenderTarget_GrSurfaceFlag;
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000209 desc.fWidth = info.width();
210 desc.fHeight = info.height();
commit-bot@chromium.org3adcc342014-04-23 19:18:09 +0000211 desc.fConfig = SkImageInfo2GrPixelConfig(info);
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000212 desc.fSampleCnt = sampleCount;
erikchen9a1ed5d2016-02-10 16:32:34 -0800213 desc.fTextureStorageAllocator = textureStorageAllocator;
cblume55f2d2d2016-02-26 13:20:48 -0800214 desc.fIsMipMapped = false;
bsalomon5ec26ae2016-02-25 08:33:02 -0800215 GrTexture* texture = context->textureProvider()->createTexture(desc, budgeted, nullptr, 0);
halcanary96fcdcc2015-08-27 07:41:13 -0700216 if (nullptr == texture) {
217 return nullptr;
kkinnunenabcfab42015-02-22 22:53:44 -0800218 }
halcanary96fcdcc2015-08-27 07:41:13 -0700219 SkASSERT(nullptr != texture->asRenderTarget());
kkinnunenabcfab42015-02-22 22:53:44 -0800220 return texture->asRenderTarget();
221}
commit-bot@chromium.org15a14052014-02-16 00:59:25 +0000222
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000223///////////////////////////////////////////////////////////////////////////////
224
commit-bot@chromium.orga713f9c2014-03-17 21:31:26 +0000225bool SkGpuDevice::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
226 int x, int y) {
joshualittce894002016-01-11 13:29:31 -0800227 ASSERT_SINGLE_OWNER
commit-bot@chromium.orga713f9c2014-03-17 21:31:26 +0000228
229 // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels
commit-bot@chromium.org3adcc342014-04-23 19:18:09 +0000230 GrPixelConfig config = SkImageInfo2GrPixelConfig(dstInfo);
commit-bot@chromium.orga713f9c2014-03-17 21:31:26 +0000231 if (kUnknown_GrPixelConfig == config) {
232 return false;
233 }
234
235 uint32_t flags = 0;
236 if (kUnpremul_SkAlphaType == dstInfo.alphaType()) {
237 flags = GrContext::kUnpremul_PixelOpsFlag;
238 }
bsalomon74f681d2015-06-23 14:38:48 -0700239 return fRenderTarget->readPixels(x, y, dstInfo.width(), dstInfo.height(), config, dstPixels,
240 dstRowBytes, flags);
commit-bot@chromium.orga713f9c2014-03-17 21:31:26 +0000241}
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000242
commit-bot@chromium.org4cd9e212014-03-07 03:25:16 +0000243bool SkGpuDevice::onWritePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes,
244 int x, int y) {
joshualittce894002016-01-11 13:29:31 -0800245 ASSERT_SINGLE_OWNER
commit-bot@chromium.org4cd9e212014-03-07 03:25:16 +0000246 // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels
commit-bot@chromium.org3adcc342014-04-23 19:18:09 +0000247 GrPixelConfig config = SkImageInfo2GrPixelConfig(info);
commit-bot@chromium.org4cd9e212014-03-07 03:25:16 +0000248 if (kUnknown_GrPixelConfig == config) {
249 return false;
250 }
251 uint32_t flags = 0;
252 if (kUnpremul_SkAlphaType == info.alphaType()) {
253 flags = GrContext::kUnpremul_PixelOpsFlag;
254 }
255 fRenderTarget->writePixels(x, y, info.width(), info.height(), config, pixels, rowBytes, flags);
256
257 // need to bump our genID for compatibility with clients that "know" we have a bitmap
reed89443ab2014-06-27 11:34:19 -0700258 fLegacyBitmap.notifyPixelsChanged();
commit-bot@chromium.org4cd9e212014-03-07 03:25:16 +0000259
260 return true;
261}
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000262
senorblanco@chromium.orgb7b7eb32014-03-19 18:24:04 +0000263const SkBitmap& SkGpuDevice::onAccessBitmap() {
joshualittce894002016-01-11 13:29:31 -0800264 ASSERT_SINGLE_OWNER
reed89443ab2014-06-27 11:34:19 -0700265 return fLegacyBitmap;
senorblanco@chromium.orgb7b7eb32014-03-19 18:24:04 +0000266}
267
reed41e010c2015-06-09 12:16:53 -0700268bool SkGpuDevice::onAccessPixels(SkPixmap* pmap) {
joshualittce894002016-01-11 13:29:31 -0800269 ASSERT_SINGLE_OWNER
reed41e010c2015-06-09 12:16:53 -0700270 // For compatibility with clients the know we're backed w/ a bitmap, and want to inspect its
271 // genID. When we can hide/remove that fact, we can eliminate this call to notify.
272 // ... ugh.
273 fLegacyBitmap.notifyPixelsChanged();
274 return false;
275}
276
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000277void SkGpuDevice::onAttachToCanvas(SkCanvas* canvas) {
joshualittce894002016-01-11 13:29:31 -0800278 ASSERT_SINGLE_OWNER
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000279 INHERITED::onAttachToCanvas(canvas);
280
281 // Canvas promises that this ptr is valid until onDetachFromCanvas is called
joshualitt44701df2015-02-23 14:44:57 -0800282 fClipStack.reset(SkRef(canvas->getClipStack()));
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000283}
284
285void SkGpuDevice::onDetachFromCanvas() {
joshualittce894002016-01-11 13:29:31 -0800286 ASSERT_SINGLE_OWNER
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000287 INHERITED::onDetachFromCanvas();
joshualitt570d2f82015-02-25 13:19:48 -0800288 fClip.reset();
halcanary96fcdcc2015-08-27 07:41:13 -0700289 fClipStack.reset(nullptr);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000290}
291
292// call this every draw call, to ensure that the context reflects our state,
293// and not the state from some other canvas/device
joshualitt5531d512014-12-17 15:50:11 -0800294void SkGpuDevice::prepareDraw(const SkDraw& draw) {
joshualittce894002016-01-11 13:29:31 -0800295 ASSERT_SINGLE_OWNER
joshualitt44701df2015-02-23 14:44:57 -0800296 SkASSERT(fClipStack.get());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000297
joshualitt44701df2015-02-23 14:44:57 -0800298 SkASSERT(draw.fClipStack && draw.fClipStack == fClipStack);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000299
joshualitt570d2f82015-02-25 13:19:48 -0800300 fClip.setClipStack(fClipStack, &this->getOrigin());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000301}
302
303GrRenderTarget* SkGpuDevice::accessRenderTarget() {
joshualittce894002016-01-11 13:29:31 -0800304 ASSERT_SINGLE_OWNER
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000305 return fRenderTarget;
306}
307
reed8eddfb52014-12-04 07:50:14 -0800308void SkGpuDevice::clearAll() {
joshualittce894002016-01-11 13:29:31 -0800309 ASSERT_SINGLE_OWNER
reed8eddfb52014-12-04 07:50:14 -0800310 GrColor color = 0;
joshualitt5651ee62016-01-11 10:39:11 -0800311 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "clearAll", fContext);
reed8eddfb52014-12-04 07:50:14 -0800312 SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
robertphillips2e1e51f2015-10-15 08:01:48 -0700313 fDrawContext->clear(&rect, color, true);
reed8eddfb52014-12-04 07:50:14 -0800314}
315
kkinnunenabcfab42015-02-22 22:53:44 -0800316void SkGpuDevice::replaceRenderTarget(bool shouldRetainContent) {
joshualittce894002016-01-11 13:29:31 -0800317 ASSERT_SINGLE_OWNER
kkinnunenabcfab42015-02-22 22:53:44 -0800318
bsalomon5ec26ae2016-02-25 08:33:02 -0800319 SkBudgeted budgeted = fRenderTarget->resourcePriv().isBudgeted();
kkinnunenabcfab42015-02-22 22:53:44 -0800320
321 SkAutoTUnref<GrRenderTarget> newRT(CreateRenderTarget(
erikchen9a1ed5d2016-02-10 16:32:34 -0800322 this->context(), budgeted, this->imageInfo(), fRenderTarget->desc().fSampleCnt,
323 fRenderTarget->desc().fTextureStorageAllocator));
kkinnunenabcfab42015-02-22 22:53:44 -0800324
halcanary96fcdcc2015-08-27 07:41:13 -0700325 if (nullptr == newRT) {
kkinnunenabcfab42015-02-22 22:53:44 -0800326 return;
327 }
328
329 if (shouldRetainContent) {
330 if (fRenderTarget->wasDestroyed()) {
331 return;
332 }
333 this->context()->copySurface(newRT, fRenderTarget);
334 }
335
336 SkASSERT(fRenderTarget != newRT);
337
joshualitt06dd0a82016-01-08 06:32:31 -0800338 fRenderTarget.reset(newRT.detach());
kkinnunenabcfab42015-02-22 22:53:44 -0800339
bsalomon74f681d2015-06-23 14:38:48 -0700340#ifdef SK_DEBUG
341 SkImageInfo info = fRenderTarget->surfacePriv().info(fOpaque ? kOpaque_SkAlphaType :
342 kPremul_SkAlphaType);
343 SkASSERT(info == fLegacyBitmap.info());
344#endif
halcanary385fe4d2015-08-26 13:07:48 -0700345 SkPixelRef* pr = new SkGrPixelRef(fLegacyBitmap.info(), fRenderTarget);
kkinnunenabcfab42015-02-22 22:53:44 -0800346 fLegacyBitmap.setPixelRef(pr)->unref();
robertphillipsea461502015-05-26 11:38:03 -0700347
robertphillips77a2e522015-10-17 07:43:27 -0700348 fDrawContext.reset(this->context()->drawContext(fRenderTarget, &this->surfaceProps()));
kkinnunenabcfab42015-02-22 22:53:44 -0800349}
350
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000351///////////////////////////////////////////////////////////////////////////////
352
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000353void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800354 ASSERT_SINGLE_OWNER
joshualitt5531d512014-12-17 15:50:11 -0800355 CHECK_SHOULD_DRAW(draw);
joshualitt5651ee62016-01-11 10:39:11 -0800356 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPaint", fContext);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000357
358 GrPaint grPaint;
bsalomonf1b7a1d2015-09-28 06:26:28 -0700359 if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700360 return;
361 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000362
robertphillips2e1e51f2015-10-15 08:01:48 -0700363 fDrawContext->drawPaint(fClip, grPaint, *draw.fMatrix);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000364}
365
366// must be in SkCanvas::PointMode order
367static const GrPrimitiveType gPointMode2PrimtiveType[] = {
368 kPoints_GrPrimitiveType,
369 kLines_GrPrimitiveType,
370 kLineStrip_GrPrimitiveType
371};
372
ethannicholas330bb952015-07-17 06:44:02 -0700373// suppress antialiasing on axis-aligned integer-coordinate lines
374static bool needs_antialiasing(SkCanvas::PointMode mode, size_t count, const SkPoint pts[]) {
375 if (mode == SkCanvas::PointMode::kPoints_PointMode) {
376 return false;
377 }
378 if (count == 2) {
379 // We do not antialias as long as the primary axis of the line is integer-aligned, even if
380 // the other coordinates are not. This does mean the two end pixels of the line will be
herb11a7f7f2015-11-24 12:41:00 -0800381 // sharp even when they shouldn't be, but turning antialiasing on (as things stand
ethannicholas330bb952015-07-17 06:44:02 -0700382 // currently) means that the line will turn into a two-pixel-wide blur. While obviously a
herb11a7f7f2015-11-24 12:41:00 -0800383 // more complete fix is possible down the road, for the time being we accept the error on
ethannicholas330bb952015-07-17 06:44:02 -0700384 // the two end pixels as being the lesser of two evils.
385 if (pts[0].fX == pts[1].fX) {
386 return ((int) pts[0].fX) != pts[0].fX;
387 }
388 if (pts[0].fY == pts[1].fY) {
389 return ((int) pts[0].fY) != pts[0].fY;
390 }
391 }
392 return true;
393}
394
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000395void SkGpuDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode,
396 size_t count, const SkPoint pts[], const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800397 ASSERT_SINGLE_OWNER
joshualitt086cee12016-01-12 06:45:24 -0800398 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPoints", fContext);
joshualitt5531d512014-12-17 15:50:11 -0800399 CHECK_SHOULD_DRAW(draw);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000400
401 SkScalar width = paint.getStrokeWidth();
402 if (width < 0) {
403 return;
404 }
405
commit-bot@chromium.org628ed0b2014-05-19 14:32:49 +0000406 if (paint.getPathEffect() && 2 == count && SkCanvas::kLines_PointMode == mode) {
egdaniele61c4112014-06-12 10:24:21 -0700407 GrStrokeInfo strokeInfo(paint, SkPaint::kStroke_Style);
408 GrPaint grPaint;
bsalomonf1b7a1d2015-09-28 06:26:28 -0700409 if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700410 return;
411 }
egdaniele61c4112014-06-12 10:24:21 -0700412 SkPath path;
jvanverthb3eb6872014-10-24 07:12:51 -0700413 path.setIsVolatile(true);
egdaniele61c4112014-06-12 10:24:21 -0700414 path.moveTo(pts[0]);
415 path.lineTo(pts[1]);
robertphillips2e1e51f2015-10-15 08:01:48 -0700416 fDrawContext->drawPath(fClip, grPaint, *draw.fMatrix, path, strokeInfo);
egdaniele61c4112014-06-12 10:24:21 -0700417 return;
commit-bot@chromium.org628ed0b2014-05-19 14:32:49 +0000418 }
419
ethannicholas330bb952015-07-17 06:44:02 -0700420 // we only handle non-antialiased hairlines and paints without path effects or mask filters,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000421 // else we let the SkDraw call our drawPath()
herb11a7f7f2015-11-24 12:41:00 -0800422 if (width > 0 || paint.getPathEffect() || paint.getMaskFilter() ||
ethannicholas330bb952015-07-17 06:44:02 -0700423 (paint.isAntiAlias() && needs_antialiasing(mode, count, pts))) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000424 draw.drawPoints(mode, count, pts, paint, true);
425 return;
426 }
427
428 GrPaint grPaint;
bsalomonf1b7a1d2015-09-28 06:26:28 -0700429 if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700430 return;
431 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000432
robertphillips2e1e51f2015-10-15 08:01:48 -0700433 fDrawContext->drawVertices(fClip,
robertphillipsea461502015-05-26 11:38:03 -0700434 grPaint,
435 *draw.fMatrix,
436 gPointMode2PrimtiveType[mode],
437 SkToS32(count),
438 (SkPoint*)pts,
halcanary96fcdcc2015-08-27 07:41:13 -0700439 nullptr,
440 nullptr,
441 nullptr,
robertphillipsea461502015-05-26 11:38:03 -0700442 0);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000443}
444
445///////////////////////////////////////////////////////////////////////////////
446
robertphillipsff55b492015-11-24 07:56:59 -0800447void SkGpuDevice::drawRect(const SkDraw& draw, const SkRect& rect, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800448 ASSERT_SINGLE_OWNER
joshualitt5651ee62016-01-11 10:39:11 -0800449 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawRect", fContext);
joshualitt5531d512014-12-17 15:50:11 -0800450 CHECK_SHOULD_DRAW(draw);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000451
452 bool doStroke = paint.getStyle() != SkPaint::kFill_Style;
453 SkScalar width = paint.getStrokeWidth();
454
455 /*
456 We have special code for hairline strokes, miter-strokes, bevel-stroke
457 and fills. Anything else we just call our path code.
458 */
459 bool usePath = doStroke && width > 0 &&
460 (paint.getStrokeJoin() == SkPaint::kRound_Join ||
461 (paint.getStrokeJoin() == SkPaint::kBevel_Join && rect.isEmpty()));
egdanield58a0ba2014-06-11 10:30:05 -0700462
robertphillipsd8aa59d2015-08-05 09:07:12 -0700463 // a few other reasons we might need to call drawPath...
robertphillipsff55b492015-11-24 07:56:59 -0800464 if (paint.getMaskFilter() || paint.getPathEffect() ||
robertphillipsd8aa59d2015-08-05 09:07:12 -0700465 paint.getStyle() == SkPaint::kStrokeAndFill_Style) { // we can't both stroke and fill rects
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000466 usePath = true;
467 }
egdanield58a0ba2014-06-11 10:30:05 -0700468
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000469 if (usePath) {
470 SkPath path;
jvanverthb3eb6872014-10-24 07:12:51 -0700471 path.setIsVolatile(true);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000472 path.addRect(rect);
robertphillips7bceedc2015-12-01 12:51:26 -0800473 GrBlurUtils::drawPathWithMaskFilter(fContext, fDrawContext,
robertphillipsff55b492015-11-24 07:56:59 -0800474 fClip, path, paint,
475 *draw.fMatrix, nullptr,
476 draw.fClip->getBounds(), true);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000477 return;
478 }
479
480 GrPaint grPaint;
bsalomonf1b7a1d2015-09-28 06:26:28 -0700481 if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700482 return;
483 }
Mike Klein744fb732014-06-23 15:13:26 -0400484
robertphillipsff55b492015-11-24 07:56:59 -0800485 GrStrokeInfo strokeInfo(paint);
486
robertphillips2e1e51f2015-10-15 08:01:48 -0700487 fDrawContext->drawRect(fClip, grPaint, *draw.fMatrix, rect, &strokeInfo);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000488}
489
490///////////////////////////////////////////////////////////////////////////////
491
492void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rect,
joshualitt5531d512014-12-17 15:50:11 -0800493 const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800494 ASSERT_SINGLE_OWNER
joshualitt5651ee62016-01-11 10:39:11 -0800495 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawRRect", fContext);
joshualitt5531d512014-12-17 15:50:11 -0800496 CHECK_SHOULD_DRAW(draw);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000497
commit-bot@chromium.org82139702014-03-10 22:53:20 +0000498 GrPaint grPaint;
bsalomonf1b7a1d2015-09-28 06:26:28 -0700499 if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700500 return;
501 }
Mike Klein744fb732014-06-23 15:13:26 -0400502
egdanield58a0ba2014-06-11 10:30:05 -0700503 GrStrokeInfo strokeInfo(paint);
commit-bot@chromium.org82139702014-03-10 22:53:20 +0000504 if (paint.getMaskFilter()) {
505 // try to hit the fast path for drawing filtered round rects
506
507 SkRRect devRRect;
joshualitt5531d512014-12-17 15:50:11 -0800508 if (rect.transform(*draw.fMatrix, &devRRect)) {
commit-bot@chromium.org82139702014-03-10 22:53:20 +0000509 if (devRRect.allCornersCircular()) {
510 SkRect maskRect;
robertphillips30c4cae2015-09-15 10:20:55 -0700511 if (paint.getMaskFilter()->canFilterMaskGPU(devRRect,
joshualitt5531d512014-12-17 15:50:11 -0800512 draw.fClip->getBounds(),
513 *draw.fMatrix,
514 &maskRect)) {
commit-bot@chromium.org82139702014-03-10 22:53:20 +0000515 SkIRect finalIRect;
516 maskRect.roundOut(&finalIRect);
517 if (draw.fClip->quickReject(finalIRect)) {
518 // clipped out
519 return;
520 }
robertphillipsff0ca5e2015-07-22 11:54:44 -0700521 if (paint.getMaskFilter()->directFilterRRectMaskGPU(fContext->textureProvider(),
522 fDrawContext,
joshualitt25d9c152015-02-18 12:29:52 -0800523 &grPaint,
joshualitt570d2f82015-02-25 13:19:48 -0800524 fClip,
joshualitt5531d512014-12-17 15:50:11 -0800525 *draw.fMatrix,
kkinnunend156d362015-05-18 22:23:54 -0700526 strokeInfo,
egdanield58a0ba2014-06-11 10:30:05 -0700527 devRRect)) {
commit-bot@chromium.org82139702014-03-10 22:53:20 +0000528 return;
529 }
530 }
531
532 }
533 }
commit-bot@chromium.org82139702014-03-10 22:53:20 +0000534 }
535
robertphillips514450c2015-11-24 05:36:02 -0800536 if (paint.getMaskFilter() || paint.getPathEffect()) {
robertphillipsff55b492015-11-24 07:56:59 -0800537 // The only mask filter the native rrect drawing code could've handle was taken
538 // care of above.
539 // A path effect will presumably transform this rrect into something else.
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000540 SkPath path;
jvanverthb3eb6872014-10-24 07:12:51 -0700541 path.setIsVolatile(true);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000542 path.addRRect(rect);
robertphillips7bceedc2015-12-01 12:51:26 -0800543 GrBlurUtils::drawPathWithMaskFilter(fContext, fDrawContext,
robertphillipsff55b492015-11-24 07:56:59 -0800544 fClip, path, paint,
545 *draw.fMatrix, nullptr,
546 draw.fClip->getBounds(), true);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000547 return;
548 }
Mike Klein744fb732014-06-23 15:13:26 -0400549
robertphillips514450c2015-11-24 05:36:02 -0800550 SkASSERT(!strokeInfo.isDashed());
551
robertphillips2e1e51f2015-10-15 08:01:48 -0700552 fDrawContext->drawRRect(fClip, grPaint, *draw.fMatrix, rect, strokeInfo);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000553}
554
robertphillipsd7706102016-02-25 09:28:08 -0800555
commit-bot@chromium.org0a09d712014-04-09 21:26:11 +0000556void SkGpuDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
joshualitt5531d512014-12-17 15:50:11 -0800557 const SkRRect& inner, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800558 ASSERT_SINGLE_OWNER
joshualitt5651ee62016-01-11 10:39:11 -0800559 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawDRRect", fContext);
robertphillips0e7029e2015-11-30 05:45:06 -0800560 CHECK_SHOULD_DRAW(draw);
561
robertphillipsd7706102016-02-25 09:28:08 -0800562 if (outer.isEmpty()) {
563 return;
564 }
565
566 if (inner.isEmpty()) {
567 return this->drawRRect(draw, outer, paint);
568 }
569
commit-bot@chromium.org0a09d712014-04-09 21:26:11 +0000570 SkStrokeRec stroke(paint);
commit-bot@chromium.org0a09d712014-04-09 21:26:11 +0000571
robertphillips0e7029e2015-11-30 05:45:06 -0800572 if (stroke.isFillStyle() && !paint.getMaskFilter() && !paint.getPathEffect()) {
robertphillips00095892016-02-29 13:50:40 -0800573 GrPaint grPaint;
574 if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700575 return;
576 }
robertphillips00095892016-02-29 13:50:40 -0800577
578 fDrawContext->drawDRRect(fClip, grPaint, *draw.fMatrix, outer, inner);
579 return;
commit-bot@chromium.org0a09d712014-04-09 21:26:11 +0000580 }
581
582 SkPath path;
jvanverthb3eb6872014-10-24 07:12:51 -0700583 path.setIsVolatile(true);
commit-bot@chromium.org0a09d712014-04-09 21:26:11 +0000584 path.addRRect(outer);
585 path.addRRect(inner);
586 path.setFillType(SkPath::kEvenOdd_FillType);
587
robertphillips7bceedc2015-12-01 12:51:26 -0800588 GrBlurUtils::drawPathWithMaskFilter(fContext, fDrawContext,
robertphillips0e7029e2015-11-30 05:45:06 -0800589 fClip, path, paint,
590 *draw.fMatrix, nullptr,
591 draw.fClip->getBounds(), true);
commit-bot@chromium.org0a09d712014-04-09 21:26:11 +0000592}
593
594
commit-bot@chromium.org82139702014-03-10 22:53:20 +0000595/////////////////////////////////////////////////////////////////////////////
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000596
robertphillips514450c2015-11-24 05:36:02 -0800597void SkGpuDevice::drawOval(const SkDraw& draw, const SkRect& oval, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800598 ASSERT_SINGLE_OWNER
joshualitt5651ee62016-01-11 10:39:11 -0800599 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawOval", fContext);
joshualitt5531d512014-12-17 15:50:11 -0800600 CHECK_SHOULD_DRAW(draw);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000601
robertphillips514450c2015-11-24 05:36:02 -0800602 // Presumably the path effect warps this to something other than an oval
603 if (paint.getPathEffect()) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000604 SkPath path;
jvanverthb3eb6872014-10-24 07:12:51 -0700605 path.setIsVolatile(true);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000606 path.addOval(oval);
halcanary96fcdcc2015-08-27 07:41:13 -0700607 this->drawPath(draw, path, paint, nullptr, true);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000608 return;
herb11a7f7f2015-11-24 12:41:00 -0800609 }
610
robertphillips514450c2015-11-24 05:36:02 -0800611 if (paint.getMaskFilter()) {
612 // The RRect path can handle special case blurring
613 SkRRect rr = SkRRect::MakeOval(oval);
614 return this->drawRRect(draw, rr, paint);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000615 }
616
617 GrPaint grPaint;
bsalomonf1b7a1d2015-09-28 06:26:28 -0700618 if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -0700619 return;
620 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000621
robertphillips514450c2015-11-24 05:36:02 -0800622 GrStrokeInfo strokeInfo(paint);
623 SkASSERT(!strokeInfo.isDashed());
624
robertphillips2e1e51f2015-10-15 08:01:48 -0700625 fDrawContext->drawOval(fClip, grPaint, *draw.fMatrix, oval, strokeInfo);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000626}
627
628#include "SkMaskFilter.h"
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000629
630///////////////////////////////////////////////////////////////////////////////
631
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000632void SkGpuDevice::drawPath(const SkDraw& draw, const SkPath& origSrcPath,
633 const SkPaint& paint, const SkMatrix* prePathMatrix,
634 bool pathIsMutable) {
joshualittce894002016-01-11 13:29:31 -0800635 ASSERT_SINGLE_OWNER
robertphillipsff55b492015-11-24 07:56:59 -0800636 if (!origSrcPath.isInverseFillType() && !paint.getPathEffect() && !prePathMatrix) {
637 bool isClosed;
638 SkRect rect;
639 if (origSrcPath.isRect(&rect, &isClosed) && isClosed) {
640 this->drawRect(draw, rect, paint);
641 return;
642 }
643 if (origSrcPath.isOval(&rect)) {
644 this->drawOval(draw, rect, paint);
645 return;
646 }
647 SkRRect rrect;
648 if (origSrcPath.isRRect(&rrect)) {
649 this->drawRRect(draw, rrect, paint);
650 return;
651 }
652 }
653
joshualitt5531d512014-12-17 15:50:11 -0800654 CHECK_SHOULD_DRAW(draw);
joshualitt5651ee62016-01-11 10:39:11 -0800655 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPath", fContext);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000656
robertphillips7bceedc2015-12-01 12:51:26 -0800657 GrBlurUtils::drawPathWithMaskFilter(fContext, fDrawContext,
robertphillipsccb1b572015-05-27 11:02:55 -0700658 fClip, origSrcPath, paint,
659 *draw.fMatrix, prePathMatrix,
660 draw.fClip->getBounds(), pathIsMutable);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000661}
662
663static const int kBmpSmallTileSize = 1 << 10;
664
665static inline int get_tile_count(const SkIRect& srcRect, int tileSize) {
666 int tilesX = (srcRect.fRight / tileSize) - (srcRect.fLeft / tileSize) + 1;
667 int tilesY = (srcRect.fBottom / tileSize) - (srcRect.fTop / tileSize) + 1;
668 return tilesX * tilesY;
669}
670
reed85d91782015-09-10 14:33:38 -0700671static int determine_tile_size(const SkIRect& src, int maxTileSize) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000672 if (maxTileSize <= kBmpSmallTileSize) {
673 return maxTileSize;
674 }
675
676 size_t maxTileTotalTileSize = get_tile_count(src, maxTileSize);
677 size_t smallTotalTileSize = get_tile_count(src, kBmpSmallTileSize);
678
679 maxTileTotalTileSize *= maxTileSize * maxTileSize;
680 smallTotalTileSize *= kBmpSmallTileSize * kBmpSmallTileSize;
681
682 if (maxTileTotalTileSize > 2 * smallTotalTileSize) {
683 return kBmpSmallTileSize;
684 } else {
685 return maxTileSize;
686 }
687}
688
689// Given a bitmap, an optional src rect, and a context with a clip and matrix determine what
690// pixels from the bitmap are necessary.
bsalomon74f681d2015-06-23 14:38:48 -0700691static void determine_clipped_src_rect(const GrRenderTarget* rt,
joshualitt570d2f82015-02-25 13:19:48 -0800692 const GrClip& clip,
joshualitt5531d512014-12-17 15:50:11 -0800693 const SkMatrix& viewMatrix,
reed85d91782015-09-10 14:33:38 -0700694 const SkISize& imageSize,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000695 const SkRect* srcRectPtr,
696 SkIRect* clippedSrcIRect) {
robertphillips7bceedc2015-12-01 12:51:26 -0800697 clip.getConservativeBounds(rt->width(), rt->height(), clippedSrcIRect, nullptr);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000698 SkMatrix inv;
joshualitt5531d512014-12-17 15:50:11 -0800699 if (!viewMatrix.invert(&inv)) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000700 clippedSrcIRect->setEmpty();
701 return;
702 }
703 SkRect clippedSrcRect = SkRect::Make(*clippedSrcIRect);
704 inv.mapRect(&clippedSrcRect);
bsalomon49f085d2014-09-05 13:34:00 -0700705 if (srcRectPtr) {
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +0000706 // we've setup src space 0,0 to map to the top left of the src rect.
707 clippedSrcRect.offset(srcRectPtr->fLeft, srcRectPtr->fTop);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000708 if (!clippedSrcRect.intersect(*srcRectPtr)) {
709 clippedSrcIRect->setEmpty();
710 return;
711 }
712 }
713 clippedSrcRect.roundOut(clippedSrcIRect);
reed85d91782015-09-10 14:33:38 -0700714 SkIRect bmpBounds = SkIRect::MakeSize(imageSize);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000715 if (!clippedSrcIRect->intersect(bmpBounds)) {
716 clippedSrcIRect->setEmpty();
717 }
718}
719
reed85d91782015-09-10 14:33:38 -0700720bool SkGpuDevice::shouldTileImageID(uint32_t imageID, const SkIRect& imageRect,
721 const SkMatrix& viewMatrix,
722 const GrTextureParams& params,
723 const SkRect* srcRectPtr,
724 int maxTileSize,
725 int* tileSize,
726 SkIRect* clippedSubset) const {
joshualittce894002016-01-11 13:29:31 -0800727 ASSERT_SINGLE_OWNER
reed85d91782015-09-10 14:33:38 -0700728 // if it's larger than the max tile size, then we have no choice but tiling.
729 if (imageRect.width() > maxTileSize || imageRect.height() > maxTileSize) {
730 determine_clipped_src_rect(fRenderTarget, fClip, viewMatrix, imageRect.size(),
731 srcRectPtr, clippedSubset);
732 *tileSize = determine_tile_size(*clippedSubset, maxTileSize);
733 return true;
734 }
735
bsalomon1a1d0b82015-10-16 07:49:42 -0700736 // If the image would only produce 4 tiles of the smaller size, don't bother tiling it.
reed85d91782015-09-10 14:33:38 -0700737 const size_t area = imageRect.width() * imageRect.height();
738 if (area < 4 * kBmpSmallTileSize * kBmpSmallTileSize) {
739 return false;
740 }
741
reed85d91782015-09-10 14:33:38 -0700742 // At this point we know we could do the draw by uploading the entire bitmap
743 // as a texture. However, if the texture would be large compared to the
744 // cache size and we don't require most of it for this draw then tile to
745 // reduce the amount of upload and cache spill.
746
747 // assumption here is that sw bitmap size is a good proxy for its size as
748 // a texture
749 size_t bmpSize = area * sizeof(SkPMColor); // assume 32bit pixels
750 size_t cacheSize;
751 fContext->getResourceCacheLimits(nullptr, &cacheSize);
752 if (bmpSize < cacheSize / 2) {
753 return false;
754 }
755
bsalomon1a1d0b82015-10-16 07:49:42 -0700756 // Figure out how much of the src we will need based on the src rect and clipping. Reject if
757 // tiling memory savings would be < 50%.
reed85d91782015-09-10 14:33:38 -0700758 determine_clipped_src_rect(fRenderTarget, fClip, viewMatrix, imageRect.size(), srcRectPtr,
759 clippedSubset);
760 *tileSize = kBmpSmallTileSize; // already know whole bitmap fits in one max sized tile.
761 size_t usedTileBytes = get_tile_count(*clippedSubset, kBmpSmallTileSize) *
762 kBmpSmallTileSize * kBmpSmallTileSize;
763
764 return usedTileBytes < 2 * bmpSize;
765}
766
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000767bool SkGpuDevice::shouldTileBitmap(const SkBitmap& bitmap,
joshualitt5531d512014-12-17 15:50:11 -0800768 const SkMatrix& viewMatrix,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000769 const GrTextureParams& params,
770 const SkRect* srcRectPtr,
771 int maxTileSize,
772 int* tileSize,
773 SkIRect* clippedSrcRect) const {
joshualittce894002016-01-11 13:29:31 -0800774 ASSERT_SINGLE_OWNER
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000775 // if bitmap is explictly texture backed then just use the texture
bsalomon49f085d2014-09-05 13:34:00 -0700776 if (bitmap.getTexture()) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000777 return false;
778 }
779
reed85d91782015-09-10 14:33:38 -0700780 return this->shouldTileImageID(bitmap.getGenerationID(), bitmap.getSubset(), viewMatrix, params,
781 srcRectPtr, maxTileSize, tileSize, clippedSrcRect);
782}
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000783
reed85d91782015-09-10 14:33:38 -0700784bool SkGpuDevice::shouldTileImage(const SkImage* image, const SkRect* srcRectPtr,
785 SkCanvas::SrcRectConstraint constraint, SkFilterQuality quality,
786 const SkMatrix& viewMatrix) const {
joshualittce894002016-01-11 13:29:31 -0800787 ASSERT_SINGLE_OWNER
reed85d91782015-09-10 14:33:38 -0700788 // if image is explictly texture backed then just use the texture
789 if (as_IB(image)->peekTexture()) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000790 return false;
791 }
792
reed85d91782015-09-10 14:33:38 -0700793 GrTextureParams params;
794 bool doBicubic;
795 GrTextureParams::FilterMode textureFilterMode =
796 GrSkFilterQualityToGrFilterMode(quality, viewMatrix, SkMatrix::I(), &doBicubic);
797
798 int tileFilterPad;
799 if (doBicubic) {
800 tileFilterPad = GrBicubicEffect::kFilterTexelPad;
801 } else if (GrTextureParams::kNone_FilterMode == textureFilterMode) {
802 tileFilterPad = 0;
803 } else {
804 tileFilterPad = 1;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000805 }
reed85d91782015-09-10 14:33:38 -0700806 params.setFilterMode(textureFilterMode);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000807
bsalomon8c07b7a2015-11-02 11:36:52 -0800808 int maxTileSize = fContext->caps()->maxTileSize() - 2 * tileFilterPad;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000809
reed85d91782015-09-10 14:33:38 -0700810 // these are output, which we safely ignore, as we just want to know the predicate
811 int outTileSize;
812 SkIRect outClippedSrcRect;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000813
reed85d91782015-09-10 14:33:38 -0700814 return this->shouldTileImageID(image->unique(), image->bounds(), viewMatrix, params, srcRectPtr,
815 maxTileSize, &outTileSize, &outClippedSrcRect);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000816}
817
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +0000818void SkGpuDevice::drawBitmap(const SkDraw& origDraw,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000819 const SkBitmap& bitmap,
820 const SkMatrix& m,
821 const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -0800822 ASSERT_SINGLE_OWNER
bsalomonb1b01992015-11-18 10:56:08 -0800823 CHECK_SHOULD_DRAW(origDraw);
bsalomonb1b01992015-11-18 10:56:08 -0800824 SkMatrix viewMatrix;
825 viewMatrix.setConcat(*origDraw.fMatrix, m);
826 if (bitmap.getTexture()) {
bsalomonc55271f2015-11-09 11:55:57 -0800827 GrBitmapTextureAdjuster adjuster(&bitmap);
bsalomonb1b01992015-11-18 10:56:08 -0800828 // We can use kFast here because we know texture-backed bitmaps don't support extractSubset.
bsalomonf1ecd212015-12-09 17:06:02 -0800829 this->drawTextureProducer(&adjuster, nullptr, nullptr, SkCanvas::kFast_SrcRectConstraint,
830 viewMatrix, fClip, paint);
bsalomonc55271f2015-11-09 11:55:57 -0800831 return;
832 }
bsalomonb1b01992015-11-18 10:56:08 -0800833 int maxTileSize = fContext->caps()->maxTileSize();
834
835 // The tile code path doesn't currently support AA, so if the paint asked for aa and we could
836 // draw untiled, then we bypass checking for tiling purely for optimization reasons.
837 bool drawAA = !fRenderTarget->isUnifiedMultisampled() &&
838 paint.isAntiAlias() &&
839 bitmap.width() <= maxTileSize &&
840 bitmap.height() <= maxTileSize;
841
842 bool skipTileCheck = drawAA || paint.getMaskFilter();
843
844 if (!skipTileCheck) {
845 SkRect srcRect = SkRect::MakeIWH(bitmap.width(), bitmap.height());
846 int tileSize;
847 SkIRect clippedSrcRect;
848
849 GrTextureParams params;
850 bool doBicubic;
851 GrTextureParams::FilterMode textureFilterMode =
852 GrSkFilterQualityToGrFilterMode(paint.getFilterQuality(), viewMatrix, SkMatrix::I(),
853 &doBicubic);
854
855 int tileFilterPad;
856
857 if (doBicubic) {
858 tileFilterPad = GrBicubicEffect::kFilterTexelPad;
859 } else if (GrTextureParams::kNone_FilterMode == textureFilterMode) {
860 tileFilterPad = 0;
861 } else {
862 tileFilterPad = 1;
863 }
864 params.setFilterMode(textureFilterMode);
865
866 int maxTileSizeForFilter = fContext->caps()->maxTileSize() - 2 * tileFilterPad;
867 if (this->shouldTileBitmap(bitmap, viewMatrix, params, &srcRect,
868 maxTileSizeForFilter, &tileSize, &clippedSrcRect)) {
869 this->drawTiledBitmap(bitmap, viewMatrix, srcRect, clippedSrcRect, params, paint,
870 SkCanvas::kStrict_SrcRectConstraint, tileSize, doBicubic);
871 return;
872 }
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +0000873 }
bsalomonb1b01992015-11-18 10:56:08 -0800874 GrBitmapTextureMaker maker(fContext, bitmap);
bsalomonf1ecd212015-12-09 17:06:02 -0800875 this->drawTextureProducer(&maker, nullptr, nullptr, SkCanvas::kStrict_SrcRectConstraint,
876 viewMatrix, fClip, paint);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000877}
878
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000879// This method outsets 'iRect' by 'outset' all around and then clamps its extents to
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000880// 'clamp'. 'offset' is adjusted to remain positioned over the top-left corner
881// of 'iRect' for all possible outsets/clamps.
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000882static inline void clamped_outset_with_offset(SkIRect* iRect,
883 int outset,
884 SkPoint* offset,
885 const SkIRect& clamp) {
886 iRect->outset(outset, outset);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000887
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000888 int leftClampDelta = clamp.fLeft - iRect->fLeft;
889 if (leftClampDelta > 0) {
890 offset->fX -= outset - leftClampDelta;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000891 iRect->fLeft = clamp.fLeft;
892 } else {
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000893 offset->fX -= outset;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000894 }
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000895
896 int topClampDelta = clamp.fTop - iRect->fTop;
897 if (topClampDelta > 0) {
898 offset->fY -= outset - topClampDelta;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000899 iRect->fTop = clamp.fTop;
900 } else {
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000901 offset->fY -= outset;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000902 }
903
904 if (iRect->fRight > clamp.fRight) {
905 iRect->fRight = clamp.fRight;
906 }
907 if (iRect->fBottom > clamp.fBottom) {
908 iRect->fBottom = clamp.fBottom;
909 }
910}
911
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000912// Break 'bitmap' into several tiles to draw it since it has already
913// been determined to be too large to fit in VRAM
914void SkGpuDevice::drawTiledBitmap(const SkBitmap& bitmap,
joshualitt5531d512014-12-17 15:50:11 -0800915 const SkMatrix& viewMatrix,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000916 const SkRect& srcRect,
917 const SkIRect& clippedSrcIRect,
918 const GrTextureParams& params,
bsalomonc55271f2015-11-09 11:55:57 -0800919 const SkPaint& origPaint,
reeda5517e22015-07-14 10:54:12 -0700920 SkCanvas::SrcRectConstraint constraint,
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000921 int tileSize,
922 bool bicubic) {
joshualittce894002016-01-11 13:29:31 -0800923 ASSERT_SINGLE_OWNER
ericrk369e9372016-02-05 15:32:36 -0800924
ericrk82e26bf2016-02-25 22:15:29 -0800925 // This is the funnel for all paths that draw tiled bitmaps/images. Log histogram entry.
ericrk369e9372016-02-05 15:32:36 -0800926 SK_HISTOGRAM_BOOLEAN("DrawTiled", true);
927
commit-bot@chromium.org9d5e3f12014-05-01 21:23:19 +0000928 // The following pixel lock is technically redundant, but it is desirable
929 // to lock outside of the tile loop to prevent redecoding the whole image
930 // at each tile in cases where 'bitmap' holds an SkDiscardablePixelRef that
931 // is larger than the limit of the discardable memory pool.
932 SkAutoLockPixels alp(bitmap);
bsalomonc55271f2015-11-09 11:55:57 -0800933
934 const SkPaint* paint = &origPaint;
935 SkPaint tempPaint;
936 if (origPaint.isAntiAlias() && !fRenderTarget->isUnifiedMultisampled()) {
937 // Drop antialiasing to avoid seams at tile boundaries.
938 tempPaint = origPaint;
939 tempPaint.setAntiAlias(false);
940 paint = &tempPaint;
941 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000942 SkRect clippedSrcRect = SkRect::Make(clippedSrcIRect);
943
944 int nx = bitmap.width() / tileSize;
945 int ny = bitmap.height() / tileSize;
946 for (int x = 0; x <= nx; x++) {
947 for (int y = 0; y <= ny; y++) {
948 SkRect tileR;
949 tileR.set(SkIntToScalar(x * tileSize),
950 SkIntToScalar(y * tileSize),
951 SkIntToScalar((x + 1) * tileSize),
952 SkIntToScalar((y + 1) * tileSize));
953
954 if (!SkRect::Intersects(tileR, clippedSrcRect)) {
955 continue;
956 }
957
958 if (!tileR.intersect(srcRect)) {
959 continue;
960 }
961
962 SkBitmap tmpB;
963 SkIRect iTileR;
964 tileR.roundOut(&iTileR);
965 SkPoint offset = SkPoint::Make(SkIntToScalar(iTileR.fLeft),
966 SkIntToScalar(iTileR.fTop));
967
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +0000968 // Adjust the context matrix to draw at the right x,y in device space
joshualitt5531d512014-12-17 15:50:11 -0800969 SkMatrix viewM = viewMatrix;
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +0000970 SkMatrix tmpM;
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +0000971 tmpM.setTranslate(offset.fX - srcRect.fLeft, offset.fY - srcRect.fTop);
joshualitt5531d512014-12-17 15:50:11 -0800972 viewM.preConcat(tmpM);
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +0000973
robertphillipsec8bb942014-11-21 10:16:25 -0800974 if (GrTextureParams::kNone_FilterMode != params.filterMode() || bicubic) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000975 SkIRect iClampRect;
976
reeda5517e22015-07-14 10:54:12 -0700977 if (SkCanvas::kFast_SrcRectConstraint == constraint) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000978 // In bleed mode we want to always expand the tile on all edges
979 // but stay within the bitmap bounds
980 iClampRect = SkIRect::MakeWH(bitmap.width(), bitmap.height());
981 } else {
982 // In texture-domain/clamp mode we only want to expand the
983 // tile on edges interior to "srcRect" (i.e., we want to
984 // not bleed across the original clamped edges)
985 srcRect.roundOut(&iClampRect);
986 }
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +0000987 int outset = bicubic ? GrBicubicEffect::kFilterTexelPad : 1;
988 clamped_outset_with_offset(&iTileR, outset, &offset, iClampRect);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +0000989 }
990
991 if (bitmap.extractSubset(&tmpB, iTileR)) {
992 // now offset it to make it "local" to our tmp bitmap
993 tileR.offset(-offset.fX, -offset.fY);
commit-bot@chromium.orga17773f2014-05-09 13:53:38 +0000994 GrTextureParams paramsTemp = params;
bsalomonb1b01992015-11-18 10:56:08 -0800995 // de-optimized this determination
996 bool needsTextureDomain = true;
commit-bot@chromium.orga17773f2014-05-09 13:53:38 +0000997 this->internalDrawBitmap(tmpB,
joshualitt5531d512014-12-17 15:50:11 -0800998 viewM,
commit-bot@chromium.orga17773f2014-05-09 13:53:38 +0000999 tileR,
1000 paramsTemp,
bsalomonc55271f2015-11-09 11:55:57 -08001001 *paint,
reeda5517e22015-07-14 10:54:12 -07001002 constraint,
commit-bot@chromium.orga17773f2014-05-09 13:53:38 +00001003 bicubic,
1004 needsTextureDomain);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001005 }
1006 }
1007 }
1008}
1009
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001010/*
1011 * This is called by drawBitmap(), which has to handle images that may be too
1012 * large to be represented by a single texture.
1013 *
1014 * internalDrawBitmap assumes that the specified bitmap will fit in a texture
1015 * and that non-texture portion of the GrPaint has already been setup.
1016 */
1017void SkGpuDevice::internalDrawBitmap(const SkBitmap& bitmap,
joshualitt5531d512014-12-17 15:50:11 -08001018 const SkMatrix& viewMatrix,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001019 const SkRect& srcRect,
1020 const GrTextureParams& params,
1021 const SkPaint& paint,
reeda5517e22015-07-14 10:54:12 -07001022 SkCanvas::SrcRectConstraint constraint,
commit-bot@chromium.orga17773f2014-05-09 13:53:38 +00001023 bool bicubic,
1024 bool needsTextureDomain) {
bsalomon9c586542015-11-02 12:33:21 -08001025 // We should have already handled bitmaps larger than the max texture size.
1026 SkASSERT(bitmap.width() <= fContext->caps()->maxTextureSize() &&
1027 bitmap.height() <= fContext->caps()->maxTextureSize());
1028 // Unless the bitmap is inherently texture-backed, we should be respecting the max tile size
1029 // by the time we get here.
1030 SkASSERT(bitmap.getTexture() ||
1031 (bitmap.width() <= fContext->caps()->maxTileSize() &&
1032 bitmap.height() <= fContext->caps()->maxTileSize()));
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001033
1034 GrTexture* texture;
bsalomonafa95e22015-10-12 10:39:46 -07001035 AutoBitmapTexture abt(fContext, bitmap, params, &texture);
halcanary96fcdcc2015-08-27 07:41:13 -07001036 if (nullptr == texture) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001037 return;
1038 }
1039
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +00001040 SkRect dstRect = {0, 0, srcRect.width(), srcRect.height() };
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001041 SkRect paintRect;
1042 SkScalar wInv = SkScalarInvert(SkIntToScalar(texture->width()));
1043 SkScalar hInv = SkScalarInvert(SkIntToScalar(texture->height()));
1044 paintRect.setLTRB(SkScalarMul(srcRect.fLeft, wInv),
1045 SkScalarMul(srcRect.fTop, hInv),
1046 SkScalarMul(srcRect.fRight, wInv),
1047 SkScalarMul(srcRect.fBottom, hInv));
1048
egdaniel79da63f2015-10-09 10:55:16 -07001049 SkMatrix texMatrix;
1050 texMatrix.reset();
1051 if (kAlpha_8_SkColorType == bitmap.colorType() && paint.getShader()) {
1052 // In cases where we are doing an A8 bitmap draw with a shader installed, we cannot use
1053 // local coords with the bitmap draw since it may mess up texture look ups for the shader.
1054 // Thus we need to pass in the transform matrix directly to the texture processor used for
1055 // the bitmap draw.
1056 texMatrix.setScale(wInv, hInv);
1057 }
1058
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001059 SkRect textureDomain = SkRect::MakeEmpty();
joshualitt5f10b5c2015-07-09 10:24:35 -07001060
1061 // Construct a GrPaint by setting the bitmap texture as the first effect and then configuring
1062 // the rest from the SkPaint.
bsalomonf1b7a1d2015-09-28 06:26:28 -07001063 SkAutoTUnref<const GrFragmentProcessor> fp;
joshualitt5f10b5c2015-07-09 10:24:35 -07001064
reeda5517e22015-07-14 10:54:12 -07001065 if (needsTextureDomain && (SkCanvas::kStrict_SrcRectConstraint == constraint)) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001066 // Use a constrained texture domain to avoid color bleeding
1067 SkScalar left, top, right, bottom;
1068 if (srcRect.width() > SK_Scalar1) {
1069 SkScalar border = SK_ScalarHalf / texture->width();
1070 left = paintRect.left() + border;
1071 right = paintRect.right() - border;
1072 } else {
1073 left = right = SkScalarHalf(paintRect.left() + paintRect.right());
1074 }
1075 if (srcRect.height() > SK_Scalar1) {
1076 SkScalar border = SK_ScalarHalf / texture->height();
1077 top = paintRect.top() + border;
1078 bottom = paintRect.bottom() - border;
1079 } else {
1080 top = bottom = SkScalarHalf(paintRect.top() + paintRect.bottom());
1081 }
1082 textureDomain.setLTRB(left, top, right, bottom);
commit-bot@chromium.org7d7f3142013-12-16 15:18:11 +00001083 if (bicubic) {
egdaniel79da63f2015-10-09 10:55:16 -07001084 fp.reset(GrBicubicEffect::Create(texture, texMatrix, textureDomain));
commit-bot@chromium.org7d7f3142013-12-16 15:18:11 +00001085 } else {
bsalomon4a339522015-10-06 08:40:50 -07001086 fp.reset(GrTextureDomainEffect::Create(texture,
egdaniel79da63f2015-10-09 10:55:16 -07001087 texMatrix,
joshualitt5531d512014-12-17 15:50:11 -08001088 textureDomain,
1089 GrTextureDomain::kClamp_Mode,
1090 params.filterMode()));
commit-bot@chromium.org7d7f3142013-12-16 15:18:11 +00001091 }
commit-bot@chromium.orgdec61502013-12-02 22:22:35 +00001092 } else if (bicubic) {
commit-bot@chromium.orgbc91fd72013-12-10 12:53:39 +00001093 SkASSERT(GrTextureParams::kNone_FilterMode == params.filterMode());
1094 SkShader::TileMode tileModes[2] = { params.getTileModeX(), params.getTileModeY() };
egdaniel79da63f2015-10-09 10:55:16 -07001095 fp.reset(GrBicubicEffect::Create(texture, texMatrix, tileModes));
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001096 } else {
egdaniel79da63f2015-10-09 10:55:16 -07001097 fp.reset(GrSimpleTextureEffect::Create(texture, texMatrix, params));
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001098 }
1099
joshualitt33a5fce2015-11-18 13:28:51 -08001100 GrPaint grPaint;
1101 if (!SkPaintToGrPaintWithTexture(this->context(), paint, viewMatrix, fp,
1102 kAlpha_8_SkColorType == bitmap.colorType(), &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -07001103 return;
1104 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001105
egdaniel79da63f2015-10-09 10:55:16 -07001106 if (kAlpha_8_SkColorType == bitmap.colorType() && paint.getShader()) {
1107 // We don't have local coords in this case and have previously set the transform
1108 // matrices directly on the texture processor.
robertphillips2e1e51f2015-10-15 08:01:48 -07001109 fDrawContext->drawRect(fClip, grPaint, viewMatrix, dstRect);
egdaniel79da63f2015-10-09 10:55:16 -07001110 } else {
bsalomona2e69fc2015-11-05 10:41:43 -08001111 fDrawContext->fillRectToRect(fClip, grPaint, viewMatrix, dstRect, paintRect);
egdaniel79da63f2015-10-09 10:55:16 -07001112 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001113}
1114
fmalita2d97bc12014-11-20 10:44:58 -08001115bool SkGpuDevice::filterTexture(GrContext* context, GrTexture* texture,
senorblancod0d37ca2015-04-02 04:54:56 -07001116 int width, int height,
fmalita2d97bc12014-11-20 10:44:58 -08001117 const SkImageFilter* filter,
1118 const SkImageFilter::Context& ctx,
1119 SkBitmap* result, SkIPoint* offset) {
joshualittce894002016-01-11 13:29:31 -08001120 ASSERT_SINGLE_OWNER
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001121 SkASSERT(filter);
fmalita2d97bc12014-11-20 10:44:58 -08001122
reed88d064d2015-10-12 11:30:02 -07001123 SkImageFilter::DeviceProxy proxy(this);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001124
1125 if (filter->canFilterImageGPU()) {
robertphillips1de87df2016-01-14 06:03:29 -08001126 SkBitmap bm;
1127 GrWrapTextureInBitmap(texture, width, height, false, &bm);
robertphillips48e78462016-02-17 13:57:16 -08001128 return filter->filterImageGPUDeprecated(&proxy, bm, ctx, result, offset);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001129 } else {
1130 return false;
1131 }
1132}
1133
1134void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
1135 int left, int top, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001136 ASSERT_SINGLE_OWNER
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001137 // drawSprite is defined to be in device coords.
joshualitt5531d512014-12-17 15:50:11 -08001138 CHECK_SHOULD_DRAW(draw);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001139
1140 SkAutoLockPixels alp(bitmap, !bitmap.getTexture());
1141 if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
1142 return;
1143 }
1144
1145 int w = bitmap.width();
1146 int h = bitmap.height();
1147
1148 GrTexture* texture;
bsalomonafa95e22015-10-12 10:39:46 -07001149 // draw sprite neither filters nor tiles.
1150 AutoBitmapTexture abt(fContext, bitmap, GrTextureParams::ClampNoFilter(), &texture);
joshualitt5f5a8d72015-02-25 14:09:45 -08001151 if (!texture) {
1152 return;
1153 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001154
bsalomonf1b7a1d2015-09-28 06:26:28 -07001155 bool alphaOnly = kAlpha_8_SkColorType == bitmap.colorType();
1156
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001157 SkImageFilter* filter = paint.getImageFilter();
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001158 // This bitmap will own the filtered result as a texture.
1159 SkBitmap filteredBitmap;
1160
bsalomon49f085d2014-09-05 13:34:00 -07001161 if (filter) {
senorblanco@chromium.org6776b822014-01-03 21:48:22 +00001162 SkIPoint offset = SkIPoint::Make(0, 0);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001163 SkMatrix matrix(*draw.fMatrix);
1164 matrix.postTranslate(SkIntToScalar(-left), SkIntToScalar(-top));
senorblancodb64af32015-12-09 10:11:43 -08001165 SkIRect clipBounds = draw.fClip->getBounds().makeOffset(-left, -top);
senorblancobe129b22014-08-08 07:14:35 -07001166 SkAutoTUnref<SkImageFilter::Cache> cache(getImageFilterCache());
senorblanco55b6d8b2014-07-30 11:26:46 -07001167 // This cache is transient, and is freed (along with all its contained
1168 // textures) when it goes out of scope.
reed4e23cda2016-01-11 10:56:59 -08001169 SkImageFilter::Context ctx(matrix, clipBounds, cache);
senorblancod0d37ca2015-04-02 04:54:56 -07001170 if (this->filterTexture(fContext, texture, w, h, filter, ctx, &filteredBitmap,
fmalita2d97bc12014-11-20 10:44:58 -08001171 &offset)) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001172 texture = (GrTexture*) filteredBitmap.getTexture();
1173 w = filteredBitmap.width();
1174 h = filteredBitmap.height();
senorblanco@chromium.org6776b822014-01-03 21:48:22 +00001175 left += offset.x();
1176 top += offset.y();
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001177 } else {
1178 return;
1179 }
bsalomonf1b7a1d2015-09-28 06:26:28 -07001180 SkASSERT(!GrPixelConfigIsAlphaOnly(texture->config()));
1181 alphaOnly = false;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001182 }
1183
1184 GrPaint grPaint;
bsalomonf1b7a1d2015-09-28 06:26:28 -07001185 SkAutoTUnref<const GrFragmentProcessor> fp(
bsalomon4a339522015-10-06 08:40:50 -07001186 GrSimpleTextureEffect::Create(texture, SkMatrix::I()));
bsalomonf1b7a1d2015-09-28 06:26:28 -07001187 if (alphaOnly) {
1188 fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
1189 } else {
1190 fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
1191 }
1192 if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -07001193 return;
1194 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001195
bsalomona2e69fc2015-11-05 10:41:43 -08001196 fDrawContext->fillRectToRect(fClip,
1197 grPaint,
1198 SkMatrix::I(),
1199 SkRect::MakeXYWH(SkIntToScalar(left),
1200 SkIntToScalar(top),
1201 SkIntToScalar(w),
1202 SkIntToScalar(h)),
1203 SkRect::MakeXYWH(0,
1204 0,
1205 SK_Scalar1 * w / texture->width(),
1206 SK_Scalar1 * h / texture->height()));
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001207}
1208
bsalomonb1b01992015-11-18 10:56:08 -08001209void SkGpuDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
1210 const SkRect* src, const SkRect& origDst,
reed562fe472015-07-28 07:35:14 -07001211 const SkPaint& paint, SkCanvas::SrcRectConstraint constraint) {
joshualittce894002016-01-11 13:29:31 -08001212 ASSERT_SINGLE_OWNER
lsalzman973ed242016-01-14 13:06:41 -08001213 CHECK_SHOULD_DRAW(draw);
bsalomonb1b01992015-11-18 10:56:08 -08001214 if (bitmap.getTexture()) {
bsalomonc55271f2015-11-09 11:55:57 -08001215 GrBitmapTextureAdjuster adjuster(&bitmap);
bsalomonf1ecd212015-12-09 17:06:02 -08001216 this->drawTextureProducer(&adjuster, src, &origDst, constraint, *draw.fMatrix, fClip,
1217 paint);
bsalomonc55271f2015-11-09 11:55:57 -08001218 return;
1219 }
bsalomonb1b01992015-11-18 10:56:08 -08001220 // The src rect is inferred to be the bmp bounds if not provided. Otherwise, the src rect must
1221 // be clipped to the bmp bounds. To determine tiling parameters we need the filter mode which
1222 // in turn requires knowing the src-to-dst mapping. If the src was clipped to the bmp bounds
1223 // then we use the src-to-dst mapping to compute a new clipped dst rect.
1224 const SkRect* dst = &origDst;
1225 const SkRect bmpBounds = SkRect::MakeIWH(bitmap.width(), bitmap.height());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001226 // Compute matrix from the two rectangles
bsalomonb1b01992015-11-18 10:56:08 -08001227 if (!src) {
1228 src = &bmpBounds;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001229 }
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +00001230
bsalomonb1b01992015-11-18 10:56:08 -08001231 SkMatrix srcToDstMatrix;
1232 if (!srcToDstMatrix.setRectToRect(*src, *dst, SkMatrix::kFill_ScaleToFit)) {
1233 return;
1234 }
1235 SkRect tmpSrc, tmpDst;
1236 if (src != &bmpBounds) {
1237 if (!bmpBounds.contains(*src)) {
1238 tmpSrc = *src;
1239 if (!tmpSrc.intersect(bmpBounds)) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001240 return; // nothing to draw
1241 }
bsalomonb1b01992015-11-18 10:56:08 -08001242 src = &tmpSrc;
1243 srcToDstMatrix.mapRect(&tmpDst, *src);
1244 dst = &tmpDst;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001245 }
1246 }
1247
bsalomonb1b01992015-11-18 10:56:08 -08001248 int maxTileSize = fContext->caps()->maxTileSize();
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +00001249
bsalomonb1b01992015-11-18 10:56:08 -08001250 // The tile code path doesn't currently support AA, so if the paint asked for aa and we could
1251 // draw untiled, then we bypass checking for tiling purely for optimization reasons.
1252 bool drawAA = !fRenderTarget->isUnifiedMultisampled() &&
1253 paint.isAntiAlias() &&
1254 bitmap.width() <= maxTileSize &&
1255 bitmap.height() <= maxTileSize;
1256
1257 bool skipTileCheck = drawAA || paint.getMaskFilter();
1258
1259 if (!skipTileCheck) {
1260 int tileSize;
1261 SkIRect clippedSrcRect;
1262
1263 GrTextureParams params;
1264 bool doBicubic;
1265 GrTextureParams::FilterMode textureFilterMode =
1266 GrSkFilterQualityToGrFilterMode(paint.getFilterQuality(), *draw.fMatrix, srcToDstMatrix,
1267 &doBicubic);
1268
1269 int tileFilterPad;
1270
1271 if (doBicubic) {
1272 tileFilterPad = GrBicubicEffect::kFilterTexelPad;
1273 } else if (GrTextureParams::kNone_FilterMode == textureFilterMode) {
1274 tileFilterPad = 0;
1275 } else {
1276 tileFilterPad = 1;
1277 }
1278 params.setFilterMode(textureFilterMode);
1279
1280 int maxTileSizeForFilter = fContext->caps()->maxTileSize() - 2 * tileFilterPad;
1281 // Fold the dst rect into the view matrix. This is only OK because we don't get here if
1282 // we have a mask filter.
1283 SkMatrix viewMatrix = *draw.fMatrix;
1284 viewMatrix.preTranslate(dst->fLeft, dst->fTop);
1285 viewMatrix.preScale(dst->width()/src->width(), dst->height()/src->height());
1286 if (this->shouldTileBitmap(bitmap, viewMatrix, params, src,
1287 maxTileSizeForFilter, &tileSize, &clippedSrcRect)) {
1288 this->drawTiledBitmap(bitmap, viewMatrix, *src, clippedSrcRect, params, paint,
1289 constraint, tileSize, doBicubic);
1290 return;
1291 }
commit-bot@chromium.orga7d89c82014-01-13 14:47:00 +00001292 }
bsalomonb1b01992015-11-18 10:56:08 -08001293 GrBitmapTextureMaker maker(fContext, bitmap);
bsalomonf1ecd212015-12-09 17:06:02 -08001294 this->drawTextureProducer(&maker, src, dst, constraint, *draw.fMatrix, fClip, paint);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001295}
1296
1297void SkGpuDevice::drawDevice(const SkDraw& draw, SkBaseDevice* device,
1298 int x, int y, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001299 ASSERT_SINGLE_OWNER
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001300 // clear of the source device must occur before CHECK_SHOULD_DRAW
joshualitt5651ee62016-01-11 10:39:11 -08001301 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawDevice", fContext);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001302 SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
kkinnunen2e4414e2015-02-19 07:20:40 -08001303
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001304 // drawDevice is defined to be in device coords.
joshualitt5531d512014-12-17 15:50:11 -08001305 CHECK_SHOULD_DRAW(draw);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001306
1307 GrRenderTarget* devRT = dev->accessRenderTarget();
1308 GrTexture* devTex;
halcanary96fcdcc2015-08-27 07:41:13 -07001309 if (nullptr == (devTex = devRT->asTexture())) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001310 return;
1311 }
1312
robertphillips7b9e8a42014-12-11 08:20:31 -08001313 const SkImageInfo ii = dev->imageInfo();
1314 int w = ii.width();
1315 int h = ii.height();
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001316
1317 SkImageFilter* filter = paint.getImageFilter();
1318 // This bitmap will own the filtered result as a texture.
1319 SkBitmap filteredBitmap;
1320
bsalomon49f085d2014-09-05 13:34:00 -07001321 if (filter) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001322 SkIPoint offset = SkIPoint::Make(0, 0);
1323 SkMatrix matrix(*draw.fMatrix);
1324 matrix.postTranslate(SkIntToScalar(-x), SkIntToScalar(-y));
senorblancodb64af32015-12-09 10:11:43 -08001325 SkIRect clipBounds = draw.fClip->getBounds().makeOffset(-x, -y);
senorblanco55b6d8b2014-07-30 11:26:46 -07001326 // This cache is transient, and is freed (along with all its contained
1327 // textures) when it goes out of scope.
senorblancobe129b22014-08-08 07:14:35 -07001328 SkAutoTUnref<SkImageFilter::Cache> cache(getImageFilterCache());
reed4e23cda2016-01-11 10:56:59 -08001329 SkImageFilter::Context ctx(matrix, clipBounds, cache);
senorblancod0d37ca2015-04-02 04:54:56 -07001330 if (this->filterTexture(fContext, devTex, device->width(), device->height(),
1331 filter, ctx, &filteredBitmap, &offset)) {
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001332 devTex = filteredBitmap.getTexture();
1333 w = filteredBitmap.width();
1334 h = filteredBitmap.height();
1335 x += offset.fX;
1336 y += offset.fY;
1337 } else {
1338 return;
1339 }
1340 }
1341
1342 GrPaint grPaint;
bsalomonf1b7a1d2015-09-28 06:26:28 -07001343 SkAutoTUnref<const GrFragmentProcessor> fp(
bsalomon4a339522015-10-06 08:40:50 -07001344 GrSimpleTextureEffect::Create(devTex, SkMatrix::I()));
bsalomonf1b7a1d2015-09-28 06:26:28 -07001345 if (GrPixelConfigIsAlphaOnly(devTex->config())) {
1346 // Can this happen?
1347 fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
1348 } else {
1349 fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
1350 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001351
bsalomonf1b7a1d2015-09-28 06:26:28 -07001352 if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -07001353 return;
1354 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001355
1356 SkRect dstRect = SkRect::MakeXYWH(SkIntToScalar(x),
1357 SkIntToScalar(y),
1358 SkIntToScalar(w),
1359 SkIntToScalar(h));
1360
1361 // The device being drawn may not fill up its texture (e.g. saveLayer uses approximate
1362 // scratch texture).
1363 SkRect srcRect = SkRect::MakeWH(SK_Scalar1 * w / devTex->width(),
1364 SK_Scalar1 * h / devTex->height());
1365
bsalomona2e69fc2015-11-05 10:41:43 -08001366 fDrawContext->fillRectToRect(fClip, grPaint, SkMatrix::I(), dstRect, srcRect);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001367}
1368
commit-bot@chromium.orgae761f72014-02-05 22:32:02 +00001369bool SkGpuDevice::canHandleImageFilter(const SkImageFilter* filter) {
joshualittce894002016-01-11 13:29:31 -08001370 ASSERT_SINGLE_OWNER
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001371 return filter->canFilterImageGPU();
1372}
1373
commit-bot@chromium.orgae761f72014-02-05 22:32:02 +00001374bool SkGpuDevice::filterImage(const SkImageFilter* filter, const SkBitmap& src,
senorblanco@chromium.org4cb543d2014-03-14 15:44:01 +00001375 const SkImageFilter::Context& ctx,
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001376 SkBitmap* result, SkIPoint* offset) {
joshualittce894002016-01-11 13:29:31 -08001377 ASSERT_SINGLE_OWNER
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001378 // want explicitly our impl, so guard against a subclass of us overriding it
1379 if (!this->SkGpuDevice::canHandleImageFilter(filter)) {
1380 return false;
1381 }
1382
1383 SkAutoLockPixels alp(src, !src.getTexture());
1384 if (!src.getTexture() && !src.readyToDraw()) {
1385 return false;
1386 }
1387
1388 GrTexture* texture;
1389 // We assume here that the filter will not attempt to tile the src. Otherwise, this cache lookup
1390 // must be pushed upstack.
bsalomonafa95e22015-10-12 10:39:46 -07001391 AutoBitmapTexture abt(fContext, src, GrTextureParams::ClampNoFilter(), &texture);
robertphillipsf83be822015-04-30 08:55:06 -07001392 if (!texture) {
1393 return false;
1394 }
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001395
senorblancod0d37ca2015-04-02 04:54:56 -07001396 return this->filterTexture(fContext, texture, src.width(), src.height(),
1397 filter, ctx, result, offset);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001398}
1399
reeda85d4d02015-05-06 12:56:48 -07001400void SkGpuDevice::drawImage(const SkDraw& draw, const SkImage* image, SkScalar x, SkScalar y,
1401 const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001402 ASSERT_SINGLE_OWNER
bsalomon1cf6f9b2015-12-08 10:53:43 -08001403 SkMatrix viewMatrix = *draw.fMatrix;
1404 viewMatrix.preTranslate(x, y);
bsalomonf1ecd212015-12-09 17:06:02 -08001405 if (as_IB(image)->peekTexture()) {
bsalomonc55271f2015-11-09 11:55:57 -08001406 CHECK_SHOULD_DRAW(draw);
bsalomonc55271f2015-11-09 11:55:57 -08001407 GrImageTextureAdjuster adjuster(as_IB(image));
bsalomonf1ecd212015-12-09 17:06:02 -08001408 this->drawTextureProducer(&adjuster, nullptr, nullptr, SkCanvas::kFast_SrcRectConstraint,
1409 viewMatrix, fClip, paint);
bsalomonc55271f2015-11-09 11:55:57 -08001410 return;
reed85d91782015-09-10 14:33:38 -07001411 } else {
bsalomon1cf6f9b2015-12-08 10:53:43 -08001412 SkBitmap bm;
reed85d91782015-09-10 14:33:38 -07001413 if (this->shouldTileImage(image, nullptr, SkCanvas::kFast_SrcRectConstraint,
1414 paint.getFilterQuality(), *draw.fMatrix)) {
1415 // only support tiling as bitmap at the moment, so force raster-version
1416 if (!as_IB(image)->getROPixels(&bm)) {
1417 return;
1418 }
bsalomon1cf6f9b2015-12-08 10:53:43 -08001419 this->drawBitmap(draw, bm, SkMatrix::MakeTrans(x, y), paint);
1420 } else if (SkImageCacherator* cacher = as_IB(image)->peekCacherator()) {
1421 CHECK_SHOULD_DRAW(draw);
1422 GrImageTextureMaker maker(fContext, cacher, image, SkImage::kAllow_CachingHint);
bsalomonf1ecd212015-12-09 17:06:02 -08001423 this->drawTextureProducer(&maker, nullptr, nullptr, SkCanvas::kFast_SrcRectConstraint,
1424 viewMatrix, fClip, paint);
bsalomon1cf6f9b2015-12-08 10:53:43 -08001425 } else if (as_IB(image)->getROPixels(&bm)) {
1426 this->drawBitmap(draw, bm, SkMatrix::MakeTrans(x, y), paint);
reed85d91782015-09-10 14:33:38 -07001427 }
reeda85d4d02015-05-06 12:56:48 -07001428 }
1429}
1430
1431void SkGpuDevice::drawImageRect(const SkDraw& draw, const SkImage* image, const SkRect* src,
reeda5517e22015-07-14 10:54:12 -07001432 const SkRect& dst, const SkPaint& paint,
1433 SkCanvas::SrcRectConstraint constraint) {
joshualittce894002016-01-11 13:29:31 -08001434 ASSERT_SINGLE_OWNER
bsalomonf1ecd212015-12-09 17:06:02 -08001435 if (as_IB(image)->peekTexture()) {
bsalomonc55271f2015-11-09 11:55:57 -08001436 CHECK_SHOULD_DRAW(draw);
1437 GrImageTextureAdjuster adjuster(as_IB(image));
bsalomonf1ecd212015-12-09 17:06:02 -08001438 this->drawTextureProducer(&adjuster, src, &dst, constraint, *draw.fMatrix, fClip, paint);
bsalomonc55271f2015-11-09 11:55:57 -08001439 return;
1440 }
1441 SkBitmap bm;
bsalomon1cf6f9b2015-12-08 10:53:43 -08001442 SkMatrix totalMatrix = *draw.fMatrix;
1443 totalMatrix.preScale(dst.width() / (src ? src->width() : image->width()),
1444 dst.height() / (src ? src->height() : image->height()));
1445 if (this->shouldTileImage(image, src, constraint, paint.getFilterQuality(), totalMatrix)) {
bsalomonc55271f2015-11-09 11:55:57 -08001446 // only support tiling as bitmap at the moment, so force raster-version
1447 if (!as_IB(image)->getROPixels(&bm)) {
1448 return;
1449 }
bsalomon1cf6f9b2015-12-08 10:53:43 -08001450 this->drawBitmapRect(draw, bm, src, dst, paint, constraint);
1451 } else if (SkImageCacherator* cacher = as_IB(image)->peekCacherator()) {
1452 CHECK_SHOULD_DRAW(draw);
1453 GrImageTextureMaker maker(fContext, cacher, image, SkImage::kAllow_CachingHint);
bsalomonf1ecd212015-12-09 17:06:02 -08001454 this->drawTextureProducer(&maker, src, &dst, constraint, *draw.fMatrix, fClip, paint);
bsalomon1cf6f9b2015-12-08 10:53:43 -08001455 } else if (as_IB(image)->getROPixels(&bm)) {
1456 this->drawBitmapRect(draw, bm, src, dst, paint, constraint);
reeda85d4d02015-05-06 12:56:48 -07001457 }
bsalomon1cf6f9b2015-12-08 10:53:43 -08001458}
1459
bsalomonf1ecd212015-12-09 17:06:02 -08001460void SkGpuDevice::drawProducerNine(const SkDraw& draw, GrTextureProducer* producer,
bsalomon2bbd0c62015-12-09 12:50:56 -08001461 const SkIRect& center, const SkRect& dst, const SkPaint& paint) {
joshualitt5651ee62016-01-11 10:39:11 -08001462 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawProducerNine", fContext);
joshualitt33a5fce2015-11-18 13:28:51 -08001463
joshualitt33a5fce2015-11-18 13:28:51 -08001464 CHECK_SHOULD_DRAW(draw);
1465
joshualittedb36442015-11-19 14:29:30 -08001466 bool useFallback = paint.getMaskFilter() || paint.isAntiAlias() ||
1467 fRenderTarget->isUnifiedMultisampled();
joshualitt33a5fce2015-11-18 13:28:51 -08001468 bool doBicubic;
1469 GrTextureParams::FilterMode textureFilterMode =
bsalomon2bbd0c62015-12-09 12:50:56 -08001470 GrSkFilterQualityToGrFilterMode(paint.getFilterQuality(), *draw.fMatrix, SkMatrix::I(),
1471 &doBicubic);
joshualitt33a5fce2015-11-18 13:28:51 -08001472 if (useFallback || doBicubic || GrTextureParams::kNone_FilterMode != textureFilterMode) {
bsalomon2bbd0c62015-12-09 12:50:56 -08001473 SkNinePatchIter iter(producer->width(), producer->height(), center, dst);
joshualitt33a5fce2015-11-18 13:28:51 -08001474
1475 SkRect srcR, dstR;
1476 while (iter.next(&srcR, &dstR)) {
erikchen9a1ed5d2016-02-10 16:32:34 -08001477 this->drawTextureProducer(producer, &srcR, &dstR, SkCanvas::kStrict_SrcRectConstraint,
bsalomonf1ecd212015-12-09 17:06:02 -08001478 *draw.fMatrix, fClip, paint);
joshualitt33a5fce2015-11-18 13:28:51 -08001479 }
1480 return;
1481 }
1482
bsalomon2bbd0c62015-12-09 12:50:56 -08001483 static const GrTextureParams::FilterMode kMode = GrTextureParams::kNone_FilterMode;
1484 SkAutoTUnref<const GrFragmentProcessor> fp(
1485 producer->createFragmentProcessor(SkMatrix::I(),
1486 SkRect::MakeIWH(producer->width(), producer->height()),
1487 GrTextureProducer::kNo_FilterConstraint, true,
1488 &kMode));
joshualitt33a5fce2015-11-18 13:28:51 -08001489 GrPaint grPaint;
1490 if (!SkPaintToGrPaintWithTexture(this->context(), paint, *draw.fMatrix, fp,
bsalomonf1ecd212015-12-09 17:06:02 -08001491 producer->isAlphaOnly(), &grPaint)) {
joshualitt33a5fce2015-11-18 13:28:51 -08001492 return;
1493 }
1494
bsalomon2bbd0c62015-12-09 12:50:56 -08001495 fDrawContext->drawImageNine(fClip, grPaint, *draw.fMatrix, producer->width(),
1496 producer->height(), center, dst);
1497}
1498
1499void SkGpuDevice::drawImageNine(const SkDraw& draw, const SkImage* image,
1500 const SkIRect& center, const SkRect& dst, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001501 ASSERT_SINGLE_OWNER
bsalomonf1ecd212015-12-09 17:06:02 -08001502 if (as_IB(image)->peekTexture()) {
bsalomon2bbd0c62015-12-09 12:50:56 -08001503 GrImageTextureAdjuster adjuster(as_IB(image));
bsalomonf1ecd212015-12-09 17:06:02 -08001504 this->drawProducerNine(draw, &adjuster, center, dst, paint);
bsalomon2bbd0c62015-12-09 12:50:56 -08001505 } else {
1506 SkBitmap bm;
1507 if (SkImageCacherator* cacher = as_IB(image)->peekCacherator()) {
1508 GrImageTextureMaker maker(fContext, cacher, image, SkImage::kAllow_CachingHint);
bsalomonf1ecd212015-12-09 17:06:02 -08001509 this->drawProducerNine(draw, &maker, center, dst, paint);
bsalomon2bbd0c62015-12-09 12:50:56 -08001510 } else if (as_IB(image)->getROPixels(&bm)) {
1511 this->drawBitmapNine(draw, bm, center, dst, paint);
1512 }
1513 }
1514}
1515
1516void SkGpuDevice::drawBitmapNine(const SkDraw& draw, const SkBitmap& bitmap, const SkIRect& center,
1517 const SkRect& dst, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001518 ASSERT_SINGLE_OWNER
bsalomon2bbd0c62015-12-09 12:50:56 -08001519 if (bitmap.getTexture()) {
1520 GrBitmapTextureAdjuster adjuster(&bitmap);
bsalomonf1ecd212015-12-09 17:06:02 -08001521 this->drawProducerNine(draw, &adjuster, center, dst, paint);
bsalomon2bbd0c62015-12-09 12:50:56 -08001522 } else {
1523 GrBitmapTextureMaker maker(fContext, bitmap);
bsalomonf1ecd212015-12-09 17:06:02 -08001524 this->drawProducerNine(draw, &maker, center, dst, paint);
bsalomon2bbd0c62015-12-09 12:50:56 -08001525 }
joshualitt33a5fce2015-11-18 13:28:51 -08001526}
1527
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001528///////////////////////////////////////////////////////////////////////////////
1529
1530// must be in SkCanvas::VertexMode order
1531static const GrPrimitiveType gVertexMode2PrimitiveType[] = {
1532 kTriangles_GrPrimitiveType,
1533 kTriangleStrip_GrPrimitiveType,
1534 kTriangleFan_GrPrimitiveType,
1535};
1536
1537void SkGpuDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
1538 int vertexCount, const SkPoint vertices[],
1539 const SkPoint texs[], const SkColor colors[],
1540 SkXfermode* xmode,
1541 const uint16_t indices[], int indexCount,
1542 const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001543 ASSERT_SINGLE_OWNER
joshualitt5531d512014-12-17 15:50:11 -08001544 CHECK_SHOULD_DRAW(draw);
joshualitt5651ee62016-01-11 10:39:11 -08001545 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawVertices", fContext);
mtklein533eb782014-08-27 10:39:42 -07001546
halcanary96fcdcc2015-08-27 07:41:13 -07001547 // If both textures and vertex-colors are nullptr, strokes hairlines with the paint's color.
1548 if ((nullptr == texs || nullptr == paint.getShader()) && nullptr == colors) {
mtklein533eb782014-08-27 10:39:42 -07001549
halcanary96fcdcc2015-08-27 07:41:13 -07001550 texs = nullptr;
mtklein533eb782014-08-27 10:39:42 -07001551
commit-bot@chromium.org559a8832014-05-30 10:08:22 +00001552 SkPaint copy(paint);
1553 copy.setStyle(SkPaint::kStroke_Style);
1554 copy.setStrokeWidth(0);
mtklein533eb782014-08-27 10:39:42 -07001555
bsalomonf1b7a1d2015-09-28 06:26:28 -07001556 GrPaint grPaint;
dandov32a311b2014-07-15 19:46:26 -07001557 // we ignore the shader if texs is null.
bsalomonf1b7a1d2015-09-28 06:26:28 -07001558 if (!SkPaintToGrPaintNoShader(this->context(), copy, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -07001559 return;
1560 }
commit-bot@chromium.org559a8832014-05-30 10:08:22 +00001561
dandov32a311b2014-07-15 19:46:26 -07001562 int triangleCount = 0;
halcanary96fcdcc2015-08-27 07:41:13 -07001563 int n = (nullptr == indices) ? vertexCount : indexCount;
dandov32a311b2014-07-15 19:46:26 -07001564 switch (vmode) {
1565 case SkCanvas::kTriangles_VertexMode:
bsalomona098dd42014-08-06 11:01:44 -07001566 triangleCount = n / 3;
dandov32a311b2014-07-15 19:46:26 -07001567 break;
1568 case SkCanvas::kTriangleStrip_VertexMode:
1569 case SkCanvas::kTriangleFan_VertexMode:
bsalomona098dd42014-08-06 11:01:44 -07001570 triangleCount = n - 2;
dandov32a311b2014-07-15 19:46:26 -07001571 break;
1572 }
mtklein533eb782014-08-27 10:39:42 -07001573
commit-bot@chromium.org559a8832014-05-30 10:08:22 +00001574 VertState state(vertexCount, indices, indexCount);
1575 VertState::Proc vertProc = state.chooseProc(vmode);
mtklein533eb782014-08-27 10:39:42 -07001576
dandov32a311b2014-07-15 19:46:26 -07001577 //number of indices for lines per triangle with kLines
1578 indexCount = triangleCount * 6;
mtklein533eb782014-08-27 10:39:42 -07001579
bsalomonf1b7a1d2015-09-28 06:26:28 -07001580 SkAutoTDeleteArray<uint16_t> lineIndices(new uint16_t[indexCount]);
commit-bot@chromium.org559a8832014-05-30 10:08:22 +00001581 int i = 0;
1582 while (vertProc(&state)) {
bsalomonf1b7a1d2015-09-28 06:26:28 -07001583 lineIndices[i] = state.f0;
1584 lineIndices[i + 1] = state.f1;
1585 lineIndices[i + 2] = state.f1;
1586 lineIndices[i + 3] = state.f2;
1587 lineIndices[i + 4] = state.f2;
1588 lineIndices[i + 5] = state.f0;
commit-bot@chromium.org559a8832014-05-30 10:08:22 +00001589 i += 6;
1590 }
robertphillips2e1e51f2015-10-15 08:01:48 -07001591 fDrawContext->drawVertices(fClip,
bsalomonf1b7a1d2015-09-28 06:26:28 -07001592 grPaint,
1593 *draw.fMatrix,
1594 kLines_GrPrimitiveType,
1595 vertexCount,
1596 vertices,
1597 texs,
1598 colors,
1599 lineIndices.get(),
1600 indexCount);
1601 return;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001602 }
1603
bsalomonf1b7a1d2015-09-28 06:26:28 -07001604 GrPrimitiveType primType = gVertexMode2PrimitiveType[vmode];
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001605
1606 SkAutoSTMalloc<128, GrColor> convertedColors(0);
bsalomon49f085d2014-09-05 13:34:00 -07001607 if (colors) {
bsalomonaa48d362015-10-01 08:34:17 -07001608 // need to convert byte order and from non-PM to PM. TODO: Keep unpremul until after
1609 // interpolation.
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001610 convertedColors.reset(vertexCount);
1611 for (int i = 0; i < vertexCount; ++i) {
bsalomonaa48d362015-10-01 08:34:17 -07001612 convertedColors[i] = SkColorToPremulGrColor(colors[i]);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001613 }
1614 colors = convertedColors.get();
1615 }
bsalomonf1b7a1d2015-09-28 06:26:28 -07001616 GrPaint grPaint;
bsalomonaa48d362015-10-01 08:34:17 -07001617 if (texs && paint.getShader()) {
1618 if (colors) {
1619 // When there are texs and colors the shader and colors are combined using xmode. A null
1620 // xmode is defined to mean modulate.
1621 SkXfermode::Mode colorMode;
1622 if (xmode) {
1623 if (!xmode->asMode(&colorMode)) {
1624 return;
1625 }
1626 } else {
1627 colorMode = SkXfermode::kModulate_Mode;
1628 }
1629 if (!SkPaintToGrPaintWithXfermode(this->context(), paint, *draw.fMatrix, colorMode,
1630 false, &grPaint)) {
bsalomonf1b7a1d2015-09-28 06:26:28 -07001631 return;
1632 }
1633 } else {
bsalomonaa48d362015-10-01 08:34:17 -07001634 // We have a shader, but no colors to blend it against.
1635 if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
1636 return;
1637 }
bsalomonf1b7a1d2015-09-28 06:26:28 -07001638 }
bsalomonaa48d362015-10-01 08:34:17 -07001639 } else {
1640 if (colors) {
1641 // We have colors, but either have no shader or no texture coords (which implies that
1642 // we should ignore the shader).
1643 if (!SkPaintToGrPaintWithPrimitiveColor(this->context(), paint, &grPaint)) {
1644 return;
1645 }
1646 } else {
1647 // No colors and no shaders. Just draw with the paint color.
1648 if (!SkPaintToGrPaintNoShader(this->context(), paint, &grPaint)) {
1649 return;
1650 }
bsalomonf1b7a1d2015-09-28 06:26:28 -07001651 }
bsalomonf1b7a1d2015-09-28 06:26:28 -07001652 }
1653
robertphillips2e1e51f2015-10-15 08:01:48 -07001654 fDrawContext->drawVertices(fClip,
robertphillipsea461502015-05-26 11:38:03 -07001655 grPaint,
1656 *draw.fMatrix,
1657 primType,
1658 vertexCount,
1659 vertices,
1660 texs,
1661 colors,
bsalomonf1b7a1d2015-09-28 06:26:28 -07001662 indices,
robertphillipsea461502015-05-26 11:38:03 -07001663 indexCount);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001664}
1665
1666///////////////////////////////////////////////////////////////////////////////
1667
jvanverth31ff7622015-08-07 10:09:28 -07001668void SkGpuDevice::drawAtlas(const SkDraw& draw, const SkImage* atlas, const SkRSXform xform[],
reedca109532015-06-25 16:25:25 -07001669 const SkRect texRect[], const SkColor colors[], int count,
1670 SkXfermode::Mode mode, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001671 ASSERT_SINGLE_OWNER
reedca109532015-06-25 16:25:25 -07001672 if (paint.isAntiAlias()) {
jvanverth31ff7622015-08-07 10:09:28 -07001673 this->INHERITED::drawAtlas(draw, atlas, xform, texRect, colors, count, mode, paint);
reedca109532015-06-25 16:25:25 -07001674 return;
1675 }
1676
jvanverth31ff7622015-08-07 10:09:28 -07001677 CHECK_SHOULD_DRAW(draw);
joshualitt5651ee62016-01-11 10:39:11 -08001678 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawText", fContext);
herb11a7f7f2015-11-24 12:41:00 -08001679
reedca109532015-06-25 16:25:25 -07001680 SkPaint p(paint);
reed5671c5b2016-03-09 14:47:34 -08001681 p.setShader(atlas->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode));
reedca109532015-06-25 16:25:25 -07001682
jvanverth31ff7622015-08-07 10:09:28 -07001683 GrPaint grPaint;
robertphillips29ccdf82015-07-24 10:20:45 -07001684 if (colors) {
bsalomonf1b7a1d2015-09-28 06:26:28 -07001685 if (!SkPaintToGrPaintWithXfermode(this->context(), p, *draw.fMatrix, mode, true,
1686 &grPaint)) {
1687 return;
1688 }
1689 } else {
1690 if (!SkPaintToGrPaint(this->context(), p, *draw.fMatrix, &grPaint)) {
jvanverth31ff7622015-08-07 10:09:28 -07001691 return;
robertphillips29ccdf82015-07-24 10:20:45 -07001692 }
1693 }
bsalomonf1b7a1d2015-09-28 06:26:28 -07001694
1695 SkDEBUGCODE(this->validate();)
robertphillips2e1e51f2015-10-15 08:01:48 -07001696 fDrawContext->drawAtlas(fClip, grPaint, *draw.fMatrix, count, xform, texRect, colors);
reedca109532015-06-25 16:25:25 -07001697}
1698
1699///////////////////////////////////////////////////////////////////////////////
1700
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001701void SkGpuDevice::drawText(const SkDraw& draw, const void* text,
joshualitt5531d512014-12-17 15:50:11 -08001702 size_t byteLength, SkScalar x, SkScalar y,
1703 const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001704 ASSERT_SINGLE_OWNER
joshualitt5531d512014-12-17 15:50:11 -08001705 CHECK_SHOULD_DRAW(draw);
joshualitt5651ee62016-01-11 10:39:11 -08001706 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawText", fContext);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001707
jvanverth8c27a182014-10-14 08:45:50 -07001708 GrPaint grPaint;
bsalomonf1b7a1d2015-09-28 06:26:28 -07001709 if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -07001710 return;
1711 }
commit-bot@chromium.org8128d8c2013-12-19 16:12:25 +00001712
jvanverth8c27a182014-10-14 08:45:50 -07001713 SkDEBUGCODE(this->validate();)
commit-bot@chromium.org8128d8c2013-12-19 16:12:25 +00001714
robertphillips2e1e51f2015-10-15 08:01:48 -07001715 fDrawContext->drawText(fClip, grPaint, paint, *draw.fMatrix,
joshualitt6e8cd962015-03-20 10:30:14 -07001716 (const char *)text, byteLength, x, y, draw.fClip->getBounds());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001717}
1718
fmalita05c4a432014-09-29 06:29:53 -07001719void SkGpuDevice::drawPosText(const SkDraw& draw, const void* text, size_t byteLength,
1720 const SkScalar pos[], int scalarsPerPos,
1721 const SkPoint& offset, const SkPaint& paint) {
joshualittce894002016-01-11 13:29:31 -08001722 ASSERT_SINGLE_OWNER
joshualitt5651ee62016-01-11 10:39:11 -08001723 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPosText", fContext);
joshualitt5531d512014-12-17 15:50:11 -08001724 CHECK_SHOULD_DRAW(draw);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001725
jvanverth8c27a182014-10-14 08:45:50 -07001726 GrPaint grPaint;
bsalomonf1b7a1d2015-09-28 06:26:28 -07001727 if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
bsalomonbed83a62015-04-15 14:18:34 -07001728 return;
1729 }
commit-bot@chromium.org8128d8c2013-12-19 16:12:25 +00001730
jvanverth8c27a182014-10-14 08:45:50 -07001731 SkDEBUGCODE(this->validate();)
commit-bot@chromium.org8128d8c2013-12-19 16:12:25 +00001732
robertphillips2e1e51f2015-10-15 08:01:48 -07001733 fDrawContext->drawPosText(fClip, grPaint, paint, *draw.fMatrix,
joshualitt6e8cd962015-03-20 10:30:14 -07001734 (const char *)text, byteLength, pos, scalarsPerPos, offset,
1735 draw.fClip->getBounds());
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001736}
1737
joshualitt9c328182015-03-23 08:13:04 -07001738void SkGpuDevice::drawTextBlob(const SkDraw& draw, const SkTextBlob* blob, SkScalar x, SkScalar y,
1739 const SkPaint& paint, SkDrawFilter* drawFilter) {
joshualittce894002016-01-11 13:29:31 -08001740 ASSERT_SINGLE_OWNER
joshualitt5651ee62016-01-11 10:39:11 -08001741 GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawTextBlob", fContext);
joshualitt9c328182015-03-23 08:13:04 -07001742 CHECK_SHOULD_DRAW(draw);
1743
1744 SkDEBUGCODE(this->validate();)
1745
robertphillips2e1e51f2015-10-15 08:01:48 -07001746 fDrawContext->drawTextBlob(fClip, paint, *draw.fMatrix,
robertphillipsccb1b572015-05-27 11:02:55 -07001747 blob, x, y, drawFilter, draw.fClip->getBounds());
joshualitt9c328182015-03-23 08:13:04 -07001748}
1749
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001750///////////////////////////////////////////////////////////////////////////////
1751
reedb2db8982014-11-13 12:41:02 -08001752bool SkGpuDevice::onShouldDisableLCD(const SkPaint& paint) const {
joshualitt8e84a1e2016-02-16 11:09:25 -08001753 return GrTextUtils::ShouldDisableLCD(paint);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001754}
1755
1756void SkGpuDevice::flush() {
joshualittce894002016-01-11 13:29:31 -08001757 ASSERT_SINGLE_OWNER
joshualittbc907352016-01-13 06:45:40 -08001758
bsalomonc49e8682015-06-30 11:37:35 -07001759 fRenderTarget->prepareForExternalIO();
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001760}
1761
1762///////////////////////////////////////////////////////////////////////////////
1763
reed76033be2015-03-14 10:54:31 -07001764SkBaseDevice* SkGpuDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint*) {
joshualittce894002016-01-11 13:29:31 -08001765 ASSERT_SINGLE_OWNER
bsalomonf2703d82014-10-28 14:33:06 -07001766 GrSurfaceDesc desc;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001767 desc.fConfig = fRenderTarget->config();
bsalomonf2703d82014-10-28 14:33:06 -07001768 desc.fFlags = kRenderTarget_GrSurfaceFlag;
fmalita6987dca2014-11-13 08:33:37 -08001769 desc.fWidth = cinfo.fInfo.width();
1770 desc.fHeight = cinfo.fInfo.height();
vbuzinovdded6962015-06-12 08:59:45 -07001771 desc.fSampleCnt = fRenderTarget->desc().fSampleCnt;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001772
1773 SkAutoTUnref<GrTexture> texture;
1774 // Skia's convention is to only clear a device if it is non-opaque.
bsalomon74f681d2015-06-23 14:38:48 -07001775 InitContents init = cinfo.fInfo.isOpaque() ? kUninit_InitContents : kClear_InitContents;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001776
hcm4396fa52014-10-27 21:43:30 -07001777 // layers are never draw in repeat modes, so we can request an approx
1778 // match and ignore any padding.
bsalomoneae62002015-07-31 13:59:30 -07001779 if (kNever_TileUsage == cinfo.fTileUsage) {
1780 texture.reset(fContext->textureProvider()->createApproxTexture(desc));
1781 } else {
bsalomon5ec26ae2016-02-25 08:33:02 -08001782 texture.reset(fContext->textureProvider()->createTexture(desc, SkBudgeted::kYes));
bsalomoneae62002015-07-31 13:59:30 -07001783 }
bsalomonafe30052015-01-16 07:32:33 -08001784
1785 if (texture) {
robertphillips7b05ff12015-06-19 14:14:54 -07001786 SkSurfaceProps props(this->surfaceProps().flags(), cinfo.fPixelGeometry);
senorblancod0d37ca2015-04-02 04:54:56 -07001787 return SkGpuDevice::Create(
bsalomon74f681d2015-06-23 14:38:48 -07001788 texture->asRenderTarget(), cinfo.fInfo.width(), cinfo.fInfo.height(), &props, init);
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001789 } else {
joshualitt5f5a8d72015-02-25 14:09:45 -08001790 SkErrorInternals::SetError( kInternalError_SkError,
reed61f501f2015-04-29 08:34:00 -07001791 "---- failed to create gpu device texture [%d %d]\n",
joshualitt5f5a8d72015-02-25 14:09:45 -08001792 cinfo.fInfo.width(), cinfo.fInfo.height());
halcanary96fcdcc2015-08-27 07:41:13 -07001793 return nullptr;
skia.committer@gmail.com11a253b2013-11-12 07:02:05 +00001794 }
1795}
1796
reed4a8126e2014-09-22 07:29:03 -07001797SkSurface* SkGpuDevice::newSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
joshualittce894002016-01-11 13:29:31 -08001798 ASSERT_SINGLE_OWNER
bsalomonafe30052015-01-16 07:32:33 -08001799 // TODO: Change the signature of newSurface to take a budgeted parameter.
bsalomon5ec26ae2016-02-25 08:33:02 -08001800 static const SkBudgeted kBudgeted = SkBudgeted::kNo;
vbuzinovdded6962015-06-12 08:59:45 -07001801 return SkSurface::NewRenderTarget(fContext, kBudgeted, info, fRenderTarget->desc().fSampleCnt,
bsalomonafe30052015-01-16 07:32:33 -08001802 &props);
reed@google.com76f10a32014-02-05 15:32:21 +00001803}
1804
robertphillips30d2cc62014-09-24 08:52:18 -07001805bool SkGpuDevice::EXPERIMENTAL_drawPicture(SkCanvas* mainCanvas, const SkPicture* mainPicture,
reedd5fa1a42014-08-09 11:08:05 -07001806 const SkMatrix* matrix, const SkPaint* paint) {
joshualittce894002016-01-11 13:29:31 -08001807 ASSERT_SINGLE_OWNER
robertphillips63242d72014-12-04 08:31:02 -08001808#ifndef SK_IGNORE_GPU_LAYER_HOISTING
robertphillips30d78412014-11-24 09:49:17 -08001809 // todo: should handle this natively
1810 if (paint) {
reedd5fa1a42014-08-09 11:08:05 -07001811 return false;
1812 }
1813
halcanary96fcdcc2015-08-27 07:41:13 -07001814 const SkBigPicture::AccelData* data = nullptr;
mtklein9db912c2015-05-19 11:11:26 -07001815 if (const SkBigPicture* bp = mainPicture->asSkBigPicture()) {
1816 data = bp->accelData();
1817 }
robertphillips81f71b62014-11-11 04:54:49 -08001818 if (!data) {
1819 return false;
1820 }
1821
robertphillipse5524cd2015-02-20 12:30:26 -08001822 const SkLayerInfo *gpuData = static_cast<const SkLayerInfo*>(data);
1823 if (0 == gpuData->numBlocks()) {
1824 return false;
commit-bot@chromium.org8ddc26b2014-03-31 17:55:12 +00001825 }
1826
robertphillipsfd61ed02014-10-28 07:21:44 -07001827 SkTDArray<GrHoistedLayer> atlasedNeedRendering, atlasedRecycled;
robertphillips1c4c5282014-09-18 12:03:15 -07001828
robertphillipse5524cd2015-02-20 12:30:26 -08001829 SkIRect iBounds;
1830 if (!mainCanvas->getClipDeviceBounds(&iBounds)) {
1831 return false;
1832 }
1833
1834 SkRect clipBounds = SkRect::Make(iBounds);
1835
1836 SkMatrix initialMatrix = mainCanvas->getTotalMatrix();
1837
robertphillips60029a52015-11-09 13:51:06 -08001838 GrLayerHoister::Begin(fContext);
1839
robertphillipsfd61ed02014-10-28 07:21:44 -07001840 GrLayerHoister::FindLayersToAtlas(fContext, mainPicture,
robertphillips30d78412014-11-24 09:49:17 -08001841 initialMatrix,
robertphillipsfd61ed02014-10-28 07:21:44 -07001842 clipBounds,
robertphillipsa63f32e2014-11-10 08:10:42 -08001843 &atlasedNeedRendering, &atlasedRecycled,
vbuzinovdded6962015-06-12 08:59:45 -07001844 fRenderTarget->numColorSamples());
robertphillipsfd61ed02014-10-28 07:21:44 -07001845
1846 GrLayerHoister::DrawLayersToAtlas(fContext, atlasedNeedRendering);
1847
1848 SkTDArray<GrHoistedLayer> needRendering, recycled;
1849
robertphillipse5524cd2015-02-20 12:30:26 -08001850 SkAutoCanvasMatrixPaint acmp(mainCanvas, matrix, paint, mainPicture->cullRect());
1851
robertphillipsfd61ed02014-10-28 07:21:44 -07001852 GrLayerHoister::FindLayersToHoist(fContext, mainPicture,
robertphillips30d78412014-11-24 09:49:17 -08001853 initialMatrix,
robertphillipsfd61ed02014-10-28 07:21:44 -07001854 clipBounds,
robertphillipsa63f32e2014-11-10 08:10:42 -08001855 &needRendering, &recycled,
vbuzinovdded6962015-06-12 08:59:45 -07001856 fRenderTarget->numColorSamples());
robertphillipsfd61ed02014-10-28 07:21:44 -07001857
1858 GrLayerHoister::DrawLayers(fContext, needRendering);
robertphillips@google.combeb1af22014-05-07 21:31:09 +00001859
robertphillips64bf7672014-08-21 13:07:35 -07001860 // Render the entire picture using new layers
robertphillipse99d4992014-12-03 07:33:57 -08001861 GrRecordReplaceDraw(mainPicture, mainCanvas, fContext->getLayerCache(),
halcanary96fcdcc2015-08-27 07:41:13 -07001862 initialMatrix, nullptr);
robertphillips64bf7672014-08-21 13:07:35 -07001863
robertphillipsfd61ed02014-10-28 07:21:44 -07001864 GrLayerHoister::UnlockLayers(fContext, needRendering);
1865 GrLayerHoister::UnlockLayers(fContext, recycled);
1866 GrLayerHoister::UnlockLayers(fContext, atlasedNeedRendering);
1867 GrLayerHoister::UnlockLayers(fContext, atlasedRecycled);
robertphillips60029a52015-11-09 13:51:06 -08001868 GrLayerHoister::End(fContext);
robertphillips64bf7672014-08-21 13:07:35 -07001869
1870 return true;
robertphillips63242d72014-12-04 08:31:02 -08001871#else
1872 return false;
1873#endif
robertphillips64bf7672014-08-21 13:07:35 -07001874}
1875
reed13ccbf82015-10-20 09:56:52 -07001876SkImageFilter::Cache* SkGpuDevice::NewImageFilterCache() {
1877 return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
1878}
1879
senorblancobe129b22014-08-08 07:14:35 -07001880SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
joshualittce894002016-01-11 13:29:31 -08001881 ASSERT_SINGLE_OWNER
senorblanco55b6d8b2014-07-30 11:26:46 -07001882 // We always return a transient cache, so it is freed after each
1883 // filter traversal.
reed13ccbf82015-10-20 09:56:52 -07001884 return SkGpuDevice::NewImageFilterCache();
senorblanco55b6d8b2014-07-30 11:26:46 -07001885}
reedf037e0b2014-10-30 11:34:15 -07001886
1887#endif