blob: ee09371e91bbfa8a3e4c5de63a84fb9746140c11 [file] [log] [blame]
reed@google.comac10a2d2010-12-22 21:39:39 +00001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * 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.
reed@google.comac10a2d2010-12-22 21:39:39 +00006 */
7
tomhudson@google.com898e7b52012-06-01 20:42:15 +00008#include "SkGpuDevice.h"
reed@google.comac10a2d2010-12-22 21:39:39 +00009
twiz@google.com58071162012-07-18 21:41:50 +000010#include "effects/GrColorTableEffect.h"
tomhudson@google.com2f68e762012-07-17 18:43:21 +000011#include "effects/GrTextureDomainEffect.h"
epoger@google.comec3ed6a2011-07-28 14:26:00 +000012
reed@google.comac10a2d2010-12-22 21:39:39 +000013#include "GrContext.h"
14#include "GrTextContext.h"
15
robertphillips@google.come9c04692012-06-29 00:30:13 +000016#include "SkGrTexturePixelRef.h"
reed@google.comac10a2d2010-12-22 21:39:39 +000017
Scroggo97c88c22011-05-11 14:05:25 +000018#include "SkColorFilter.h"
senorblanco@chromium.org9c397442012-09-27 21:57:45 +000019#include "SkDeviceImageFilterProxy.h"
reed@google.comac10a2d2010-12-22 21:39:39 +000020#include "SkDrawProcs.h"
21#include "SkGlyphCache.h"
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +000022#include "SkImageFilter.h"
reed@google.comfe626382011-09-21 13:50:35 +000023#include "SkTLazy.h"
reed@google.comc9aa5872011-04-05 21:05:37 +000024#include "SkUtils.h"
reed@google.comac10a2d2010-12-22 21:39:39 +000025
bsalomon@google.com06cd7322012-03-30 18:45:35 +000026#define CACHE_COMPATIBLE_DEVICE_TEXTURES 1
reed@google.comac10a2d2010-12-22 21:39:39 +000027
28#if 0
29 extern bool (*gShouldDrawProc)();
30 #define CHECK_SHOULD_DRAW(draw) \
31 do { \
32 if (gShouldDrawProc && !gShouldDrawProc()) return; \
33 this->prepareRenderTarget(draw); \
bsalomon@google.com06cd7322012-03-30 18:45:35 +000034 GrAssert(!fNeedClear) \
reed@google.comac10a2d2010-12-22 21:39:39 +000035 } while (0)
36#else
bsalomon@google.com06cd7322012-03-30 18:45:35 +000037 #define CHECK_SHOULD_DRAW(draw) this->prepareRenderTarget(draw); \
38 GrAssert(!fNeedClear)
reed@google.comac10a2d2010-12-22 21:39:39 +000039#endif
40
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +000041// we use the same texture slot on GrPaint for bitmaps and shaders
42// (since drawBitmap, drawSprite, and drawDevice ignore skia's shader)
43enum {
44 kBitmapTextureIdx = 0,
twiz@google.com58071162012-07-18 21:41:50 +000045 kShaderTextureIdx = 0,
46 kColorFilterTextureIdx = 1
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +000047};
48
reed@google.comcde92112011-07-06 20:00:52 +000049
senorblanco@chromium.orge36ddf02011-07-15 14:28:16 +000050#define MAX_BLUR_SIGMA 4.0f
51// FIXME: This value comes from from SkBlurMaskFilter.cpp.
52// Should probably be put in a common header someplace.
53#define MAX_BLUR_RADIUS SkIntToScalar(128)
54// This constant approximates the scaling done in the software path's
55// "high quality" mode, in SkBlurMask::Blur() (1 / sqrt(3)).
56// IMHO, it actually should be 1: we blur "less" than we should do
57// according to the CSS and canvas specs, simply because Safari does the same.
58// Firefox used to do the same too, until 4.0 where they fixed it. So at some
59// point we should probably get rid of these scaling constants and rebaseline
60// all the blur tests.
61#define BLUR_SIGMA_SCALE 0.6f
junov@chromium.orgf32a9b62012-03-16 20:54:17 +000062// This constant represents the screen alignment criterion in texels for
rmistry@google.comd6176b02012-08-23 18:14:13 +000063// requiring texture domain clamping to prevent color bleeding when drawing
junov@chromium.orgf32a9b62012-03-16 20:54:17 +000064// a sub region of a larger source image.
65#define COLOR_BLEED_TOLERANCE SkFloatToScalar(0.001f)
bsalomon@google.com06cd7322012-03-30 18:45:35 +000066
67#define DO_DEFERRED_CLEAR \
68 do { \
69 if (fNeedClear) { \
bsalomon@google.com730ca3b2012-04-03 13:25:12 +000070 this->clear(0x0); \
bsalomon@google.com06cd7322012-03-30 18:45:35 +000071 fNeedClear = false; \
72 } \
73 } while (false) \
74
reed@google.comac10a2d2010-12-22 21:39:39 +000075///////////////////////////////////////////////////////////////////////////////
76
reed@google.comb0a34d82012-07-11 19:57:55 +000077#define CHECK_FOR_NODRAW_ANNOTATION(paint) \
78 do { if (paint.isNoDrawAnnotation()) { return; } } while (0)
79
80///////////////////////////////////////////////////////////////////////////////
81
82
bsalomon@google.com84405e02012-03-05 19:57:21 +000083class SkGpuDevice::SkAutoCachedTexture : public ::SkNoncopyable {
84public:
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +000085 SkAutoCachedTexture()
86 : fDevice(NULL)
87 , fTexture(NULL) {
rmistry@google.comd6176b02012-08-23 18:14:13 +000088 }
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +000089
bsalomon@google.com84405e02012-03-05 19:57:21 +000090 SkAutoCachedTexture(SkGpuDevice* device,
91 const SkBitmap& bitmap,
bsalomon@google.comb8670992012-07-25 21:27:09 +000092 const GrTextureParams* params,
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +000093 GrTexture** texture)
94 : fDevice(NULL)
95 , fTexture(NULL) {
96 GrAssert(NULL != texture);
bsalomon@google.comb8670992012-07-25 21:27:09 +000097 *texture = this->set(device, bitmap, params);
reed@google.comac10a2d2010-12-22 21:39:39 +000098 }
reed@google.comac10a2d2010-12-22 21:39:39 +000099
bsalomon@google.com84405e02012-03-05 19:57:21 +0000100 ~SkAutoCachedTexture() {
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000101 if (NULL != fTexture) {
102 GrUnlockCachedBitmapTexture(fTexture);
bsalomon@google.com84405e02012-03-05 19:57:21 +0000103 }
reed@google.comac10a2d2010-12-22 21:39:39 +0000104 }
bsalomon@google.com84405e02012-03-05 19:57:21 +0000105
106 GrTexture* set(SkGpuDevice* device,
107 const SkBitmap& bitmap,
bsalomon@google.comb8670992012-07-25 21:27:09 +0000108 const GrTextureParams* params) {
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000109 if (NULL != fTexture) {
110 GrUnlockCachedBitmapTexture(fTexture);
111 fTexture = NULL;
bsalomon@google.com84405e02012-03-05 19:57:21 +0000112 }
113 fDevice = device;
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000114 GrTexture* result = (GrTexture*)bitmap.getTexture();
115 if (NULL == result) {
116 // Cannot return the native texture so look it up in our cache
117 fTexture = GrLockCachedBitmapTexture(device->context(), bitmap, params);
118 result = fTexture;
bsalomon@google.com84405e02012-03-05 19:57:21 +0000119 }
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000120 return result;
bsalomon@google.com84405e02012-03-05 19:57:21 +0000121 }
rmistry@google.comd6176b02012-08-23 18:14:13 +0000122
bsalomon@google.com84405e02012-03-05 19:57:21 +0000123private:
124 SkGpuDevice* fDevice;
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000125 GrTexture* fTexture;
bsalomon@google.com84405e02012-03-05 19:57:21 +0000126};
reed@google.comac10a2d2010-12-22 21:39:39 +0000127
128///////////////////////////////////////////////////////////////////////////////
129
130bool gDoTraceDraw;
131
132struct GrSkDrawProcs : public SkDrawProcs {
133public:
134 GrContext* fContext;
135 GrTextContext* fTextContext;
136 GrFontScaler* fFontScaler; // cached in the skia glyphcache
137};
138
139///////////////////////////////////////////////////////////////////////////////
140
reed@google.comaf951c92011-06-16 19:10:39 +0000141static SkBitmap::Config grConfig2skConfig(GrPixelConfig config, bool* isOpaque) {
142 switch (config) {
143 case kAlpha_8_GrPixelConfig:
144 *isOpaque = false;
145 return SkBitmap::kA8_Config;
146 case kRGB_565_GrPixelConfig:
147 *isOpaque = true;
148 return SkBitmap::kRGB_565_Config;
149 case kRGBA_4444_GrPixelConfig:
150 *isOpaque = false;
151 return SkBitmap::kARGB_4444_Config;
bsalomon@google.comc4364992011-11-07 15:54:49 +0000152 case kSkia8888_PM_GrPixelConfig:
153 // we don't currently have a way of knowing whether
154 // a 8888 is opaque based on the config.
155 *isOpaque = false;
reed@google.comaf951c92011-06-16 19:10:39 +0000156 return SkBitmap::kARGB_8888_Config;
157 default:
158 *isOpaque = false;
159 return SkBitmap::kNo_Config;
160 }
161}
reed@google.comac10a2d2010-12-22 21:39:39 +0000162
reed@google.comaf951c92011-06-16 19:10:39 +0000163static SkBitmap make_bitmap(GrContext* context, GrRenderTarget* renderTarget) {
bsalomon@google.com971d0c82011-08-19 17:22:05 +0000164 GrPixelConfig config = renderTarget->config();
reed@google.comaf951c92011-06-16 19:10:39 +0000165
166 bool isOpaque;
167 SkBitmap bitmap;
168 bitmap.setConfig(grConfig2skConfig(config, &isOpaque),
169 renderTarget->width(), renderTarget->height());
170 bitmap.setIsOpaque(isOpaque);
171 return bitmap;
172}
173
bsalomon@google.comf9046fe2011-06-17 15:10:21 +0000174SkGpuDevice::SkGpuDevice(GrContext* context, GrTexture* texture)
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000175: SkDevice(make_bitmap(context, texture->asRenderTarget())) {
bsalomon@google.com8090e652012-08-28 15:07:11 +0000176 this->initFromRenderTarget(context, texture->asRenderTarget(), false);
bsalomon@google.comf9046fe2011-06-17 15:10:21 +0000177}
178
reed@google.comaf951c92011-06-16 19:10:39 +0000179SkGpuDevice::SkGpuDevice(GrContext* context, GrRenderTarget* renderTarget)
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000180: SkDevice(make_bitmap(context, renderTarget)) {
bsalomon@google.com8090e652012-08-28 15:07:11 +0000181 this->initFromRenderTarget(context, renderTarget, false);
bsalomon@google.comf9046fe2011-06-17 15:10:21 +0000182}
183
vandebo@chromium.org74b46192012-01-28 01:45:11 +0000184void SkGpuDevice::initFromRenderTarget(GrContext* context,
bsalomon@google.com8090e652012-08-28 15:07:11 +0000185 GrRenderTarget* renderTarget,
186 bool cached) {
reed@google.comaf951c92011-06-16 19:10:39 +0000187 fNeedPrepareRenderTarget = false;
188 fDrawProcs = NULL;
vandebo@chromium.org74b46192012-01-28 01:45:11 +0000189
reed@google.comaf951c92011-06-16 19:10:39 +0000190 fContext = context;
191 fContext->ref();
vandebo@chromium.org74b46192012-01-28 01:45:11 +0000192
reed@google.comaf951c92011-06-16 19:10:39 +0000193 fRenderTarget = NULL;
194 fNeedClear = false;
vandebo@chromium.org74b46192012-01-28 01:45:11 +0000195
bsalomon@google.com971d0c82011-08-19 17:22:05 +0000196 GrAssert(NULL != renderTarget);
197 fRenderTarget = renderTarget;
198 fRenderTarget->ref();
rmistry@google.comd6176b02012-08-23 18:14:13 +0000199
bsalomon@google.coma2921122012-08-28 12:34:17 +0000200 // Hold onto to the texture in the pixel ref (if there is one) because the texture holds a ref
201 // on the RT but not vice-versa.
202 // TODO: Remove this trickery once we figure out how to make SkGrPixelRef do this without
203 // busting chrome (for a currently unknown reason).
204 GrSurface* surface = fRenderTarget->asTexture();
205 if (NULL == surface) {
206 surface = fRenderTarget;
bsalomon@google.comd9ce1252012-01-24 02:31:42 +0000207 }
bsalomon@google.com8090e652012-08-28 15:07:11 +0000208 SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (surface, cached));
bsalomon@google.coma2921122012-08-28 12:34:17 +0000209
reed@google.comaf951c92011-06-16 19:10:39 +0000210 this->setPixelRef(pr, 0)->unref();
211}
212
bsalomon@google.com06cd7322012-03-30 18:45:35 +0000213SkGpuDevice::SkGpuDevice(GrContext* context,
214 SkBitmap::Config config,
215 int width,
216 int height)
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000217 : SkDevice(config, width, height, false /*isOpaque*/) {
218
reed@google.comac10a2d2010-12-22 21:39:39 +0000219 fNeedPrepareRenderTarget = false;
220 fDrawProcs = NULL;
221
reed@google.com7b201d22011-01-11 18:59:23 +0000222 fContext = context;
bsalomon@google.com5782d712011-01-21 21:03:59 +0000223 fContext->ref();
reed@google.comac10a2d2010-12-22 21:39:39 +0000224
reed@google.comac10a2d2010-12-22 21:39:39 +0000225 fRenderTarget = NULL;
226 fNeedClear = false;
227
reed@google.comaf951c92011-06-16 19:10:39 +0000228 if (config != SkBitmap::kRGB_565_Config) {
229 config = SkBitmap::kARGB_8888_Config;
230 }
231 SkBitmap bm;
232 bm.setConfig(config, width, height);
reed@google.comac10a2d2010-12-22 21:39:39 +0000233
robertphillips@google.com75b3c962012-06-07 12:08:45 +0000234 GrTextureDesc desc;
235 desc.fFlags = kRenderTarget_GrTextureFlagBit;
236 desc.fWidth = width;
237 desc.fHeight = height;
rileya@google.com24f3ad12012-07-18 21:47:40 +0000238 desc.fConfig = SkBitmapConfig2GrPixelConfig(bm.config());
reed@google.comac10a2d2010-12-22 21:39:39 +0000239
bsalomon@google.coma2921122012-08-28 12:34:17 +0000240 SkAutoTUnref<GrTexture> texture(fContext->createUncachedTexture(desc, NULL, 0));
bsalomon@google.com06cd7322012-03-30 18:45:35 +0000241
bsalomon@google.coma2921122012-08-28 12:34:17 +0000242 if (NULL != texture) {
243 fRenderTarget = texture->asRenderTarget();
bsalomon@google.comf9046fe2011-06-17 15:10:21 +0000244 fRenderTarget->ref();
reed@google.comac10a2d2010-12-22 21:39:39 +0000245
reed@google.comaf951c92011-06-16 19:10:39 +0000246 GrAssert(NULL != fRenderTarget);
reed@google.comac10a2d2010-12-22 21:39:39 +0000247
reed@google.comaf951c92011-06-16 19:10:39 +0000248 // wrap the bitmap with a pixelref to expose our texture
bsalomon@google.coma2921122012-08-28 12:34:17 +0000249 SkGrPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (texture));
bsalomon@google.com669fdc42011-04-05 17:08:27 +0000250 this->setPixelRef(pr, 0)->unref();
reed@google.comaf951c92011-06-16 19:10:39 +0000251 } else {
252 GrPrintf("--- failed to create gpu-offscreen [%d %d]\n",
253 width, height);
254 GrAssert(false);
reed@google.comac10a2d2010-12-22 21:39:39 +0000255 }
256}
257
258SkGpuDevice::~SkGpuDevice() {
259 if (fDrawProcs) {
260 delete fDrawProcs;
261 }
262
robertphillips@google.com9ec07532012-06-22 12:01:30 +0000263 // The SkGpuDevice gives the context the render target (e.g., in gainFocus)
rmistry@google.comd6176b02012-08-23 18:14:13 +0000264 // This call gives the context a chance to relinquish it
robertphillips@google.com9ec07532012-06-22 12:01:30 +0000265 fContext->setRenderTarget(NULL);
266
bsalomon@google.coma2921122012-08-28 12:34:17 +0000267 SkSafeUnref(fRenderTarget);
bsalomon@google.com5782d712011-01-21 21:03:59 +0000268 fContext->unref();
reed@google.comac10a2d2010-12-22 21:39:39 +0000269}
270
reed@google.comac10a2d2010-12-22 21:39:39 +0000271///////////////////////////////////////////////////////////////////////////////
272
273void SkGpuDevice::makeRenderTargetCurrent() {
bsalomon@google.com06cd7322012-03-30 18:45:35 +0000274 DO_DEFERRED_CLEAR;
reed@google.comac10a2d2010-12-22 21:39:39 +0000275 fContext->setRenderTarget(fRenderTarget);
reed@google.comac10a2d2010-12-22 21:39:39 +0000276 fNeedPrepareRenderTarget = true;
277}
278
279///////////////////////////////////////////////////////////////////////////////
280
bsalomon@google.comc4364992011-11-07 15:54:49 +0000281namespace {
bsalomon@google.com0342a852012-08-20 19:22:38 +0000282GrPixelConfig config8888_to_grconfig_and_flags(SkCanvas::Config8888 config8888, uint32_t* flags) {
bsalomon@google.comc4364992011-11-07 15:54:49 +0000283 switch (config8888) {
284 case SkCanvas::kNative_Premul_Config8888:
bsalomon@google.com0342a852012-08-20 19:22:38 +0000285 *flags = 0;
286 return kSkia8888_GrPixelConfig;
bsalomon@google.comc4364992011-11-07 15:54:49 +0000287 case SkCanvas::kNative_Unpremul_Config8888:
bsalomon@google.com0342a852012-08-20 19:22:38 +0000288 *flags = GrContext::kUnpremul_PixelOpsFlag;
289 return kSkia8888_PM_GrPixelConfig;
bsalomon@google.comc4364992011-11-07 15:54:49 +0000290 case SkCanvas::kBGRA_Premul_Config8888:
bsalomon@google.com0342a852012-08-20 19:22:38 +0000291 *flags = 0;
292 return kBGRA_8888_GrPixelConfig;
bsalomon@google.comc4364992011-11-07 15:54:49 +0000293 case SkCanvas::kBGRA_Unpremul_Config8888:
bsalomon@google.com0342a852012-08-20 19:22:38 +0000294 *flags = GrContext::kUnpremul_PixelOpsFlag;
295 return kBGRA_8888_GrPixelConfig;
bsalomon@google.comc4364992011-11-07 15:54:49 +0000296 case SkCanvas::kRGBA_Premul_Config8888:
bsalomon@google.com0342a852012-08-20 19:22:38 +0000297 *flags = 0;
298 return kRGBA_8888_GrPixelConfig;
bsalomon@google.comc4364992011-11-07 15:54:49 +0000299 case SkCanvas::kRGBA_Unpremul_Config8888:
bsalomon@google.com0342a852012-08-20 19:22:38 +0000300 *flags = GrContext::kUnpremul_PixelOpsFlag;
301 return kRGBA_8888_GrPixelConfig;
bsalomon@google.comc4364992011-11-07 15:54:49 +0000302 default:
303 GrCrash("Unexpected Config8888.");
bsalomon@google.comccaa0022012-09-25 19:55:07 +0000304 *flags = 0; // suppress warning
bsalomon@google.comc4364992011-11-07 15:54:49 +0000305 return kSkia8888_PM_GrPixelConfig;
306 }
307}
308}
309
bsalomon@google.com6850eab2011-11-03 20:29:47 +0000310bool SkGpuDevice::onReadPixels(const SkBitmap& bitmap,
311 int x, int y,
312 SkCanvas::Config8888 config8888) {
bsalomon@google.com06cd7322012-03-30 18:45:35 +0000313 DO_DEFERRED_CLEAR;
bsalomon@google.com910267d2011-11-02 20:06:25 +0000314 SkASSERT(SkBitmap::kARGB_8888_Config == bitmap.config());
315 SkASSERT(!bitmap.isNull());
316 SkASSERT(SkIRect::MakeWH(this->width(), this->height()).contains(SkIRect::MakeXYWH(x, y, bitmap.width(), bitmap.height())));
reed@google.comac10a2d2010-12-22 21:39:39 +0000317
bsalomon@google.com910267d2011-11-02 20:06:25 +0000318 SkAutoLockPixels alp(bitmap);
bsalomon@google.comc4364992011-11-07 15:54:49 +0000319 GrPixelConfig config;
bsalomon@google.com0342a852012-08-20 19:22:38 +0000320 uint32_t flags;
321 config = config8888_to_grconfig_and_flags(config8888, &flags);
bsalomon@google.comc6980972011-11-02 19:57:21 +0000322 return fContext->readRenderTargetPixels(fRenderTarget,
323 x, y,
bsalomon@google.com910267d2011-11-02 20:06:25 +0000324 bitmap.width(),
325 bitmap.height(),
bsalomon@google.comc4364992011-11-07 15:54:49 +0000326 config,
bsalomon@google.com910267d2011-11-02 20:06:25 +0000327 bitmap.getPixels(),
bsalomon@google.com0342a852012-08-20 19:22:38 +0000328 bitmap.rowBytes(),
329 flags);
reed@google.comac10a2d2010-12-22 21:39:39 +0000330}
331
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000332void SkGpuDevice::writePixels(const SkBitmap& bitmap, int x, int y,
333 SkCanvas::Config8888 config8888) {
reed@google.comac10a2d2010-12-22 21:39:39 +0000334 SkAutoLockPixels alp(bitmap);
335 if (!bitmap.readyToDraw()) {
336 return;
337 }
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000338
339 GrPixelConfig config;
bsalomon@google.com0342a852012-08-20 19:22:38 +0000340 uint32_t flags;
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000341 if (SkBitmap::kARGB_8888_Config == bitmap.config()) {
bsalomon@google.com0342a852012-08-20 19:22:38 +0000342 config = config8888_to_grconfig_and_flags(config8888, &flags);
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000343 } else {
bsalomon@google.com0342a852012-08-20 19:22:38 +0000344 flags = 0;
rileya@google.com24f3ad12012-07-18 21:47:40 +0000345 config= SkBitmapConfig2GrPixelConfig(bitmap.config());
bsalomon@google.comd58a1cd2011-11-10 20:57:43 +0000346 }
347
bsalomon@google.com6f379512011-11-16 20:36:03 +0000348 fRenderTarget->writePixels(x, y, bitmap.width(), bitmap.height(),
bsalomon@google.com0342a852012-08-20 19:22:38 +0000349 config, bitmap.getPixels(), bitmap.rowBytes(), flags);
reed@google.comac10a2d2010-12-22 21:39:39 +0000350}
351
robertphillips@google.com46f93502012-08-07 15:38:08 +0000352namespace {
353void purgeClipCB(int genID, void* data) {
354 GrContext* context = (GrContext*) data;
355
356 if (SkClipStack::kInvalidGenID == genID ||
357 SkClipStack::kEmptyGenID == genID ||
358 SkClipStack::kWideOpenGenID == genID) {
359 // none of these cases will have a cached clip mask
360 return;
361 }
362
363}
364};
365
robertphillips@google.com40a1ae42012-07-13 15:36:15 +0000366void SkGpuDevice::onAttachToCanvas(SkCanvas* canvas) {
367 INHERITED::onAttachToCanvas(canvas);
368
369 // Canvas promises that this ptr is valid until onDetachFromCanvas is called
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000370 fClipData.fClipStack = canvas->getClipStack();
robertphillips@google.com46f93502012-08-07 15:38:08 +0000371
372 fClipData.fClipStack->addPurgeClipCallback(purgeClipCB, fContext);
robertphillips@google.com40a1ae42012-07-13 15:36:15 +0000373}
374
375void SkGpuDevice::onDetachFromCanvas() {
376 INHERITED::onDetachFromCanvas();
377
robertphillips@google.com46f93502012-08-07 15:38:08 +0000378 // TODO: iterate through the clip stack and clean up any cached clip masks
379 fClipData.fClipStack->removePurgeClipCallback(purgeClipCB, fContext);
380
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000381 fClipData.fClipStack = NULL;
robertphillips@google.com40a1ae42012-07-13 15:36:15 +0000382}
383
robertphillips@google.com607fe072012-07-24 13:54:00 +0000384#ifdef SK_DEBUG
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000385static void check_bounds(const GrClipData& clipData,
robertphillips@google.com607fe072012-07-24 13:54:00 +0000386 const SkRegion& clipRegion,
robertphillips@google.com607fe072012-07-24 13:54:00 +0000387 int renderTargetWidth,
388 int renderTargetHeight) {
389
robertphillips@google.com7b112892012-07-31 15:18:21 +0000390 SkIRect devBound;
391
392 devBound.setLTRB(0, 0, renderTargetWidth, renderTargetHeight);
393
robertphillips@google.com607fe072012-07-24 13:54:00 +0000394 SkClipStack::BoundsType boundType;
robertphillips@google.com7b112892012-07-31 15:18:21 +0000395 SkRect canvTemp;
robertphillips@google.com607fe072012-07-24 13:54:00 +0000396
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000397 clipData.fClipStack->getBounds(&canvTemp, &boundType);
robertphillips@google.com607fe072012-07-24 13:54:00 +0000398 if (SkClipStack::kNormal_BoundsType == boundType) {
robertphillips@google.com7b112892012-07-31 15:18:21 +0000399 SkIRect devTemp;
robertphillips@google.com607fe072012-07-24 13:54:00 +0000400
robertphillips@google.com7b112892012-07-31 15:18:21 +0000401 canvTemp.roundOut(&devTemp);
robertphillips@google.com607fe072012-07-24 13:54:00 +0000402
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000403 devTemp.offset(-clipData.fOrigin.fX, -clipData.fOrigin.fY);
robertphillips@google.com607fe072012-07-24 13:54:00 +0000404
robertphillips@google.com7b112892012-07-31 15:18:21 +0000405 if (!devBound.intersect(devTemp)) {
406 devBound.setEmpty();
robertphillips@google.com607fe072012-07-24 13:54:00 +0000407 }
408 }
409
robertphillips@google.com768fee82012-08-02 12:42:43 +0000410 GrAssert(devBound.contains(clipRegion.getBounds()));
robertphillips@google.com607fe072012-07-24 13:54:00 +0000411}
412#endif
413
reed@google.comac10a2d2010-12-22 21:39:39 +0000414///////////////////////////////////////////////////////////////////////////////
415
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000416static void set_matrix_and_clip(GrContext* context, const SkMatrix& matrix,
417 GrClipData& clipData,
418 const SkRegion& clipRegion,
419 const SkIPoint& origin,
420 int renderTargetWidth, int renderTargetHeight) {
bsalomon@google.comcc4dac32011-05-10 13:52:42 +0000421 context->setMatrix(matrix);
reed@google.comac10a2d2010-12-22 21:39:39 +0000422
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000423 clipData.fOrigin = origin;
robertphillips@google.com607fe072012-07-24 13:54:00 +0000424
425#ifdef SK_DEBUG
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000426 check_bounds(clipData, clipRegion,
robertphillips@google.com607fe072012-07-24 13:54:00 +0000427 renderTargetWidth, renderTargetHeight);
428#endif
429
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000430 context->setClip(&clipData);
reed@google.comac10a2d2010-12-22 21:39:39 +0000431}
432
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000433// call this every draw call, to ensure that the context reflects our state,
reed@google.comac10a2d2010-12-22 21:39:39 +0000434// and not the state from some other canvas/device
435void SkGpuDevice::prepareRenderTarget(const SkDraw& draw) {
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000436 GrAssert(NULL != fClipData.fClipStack);
robertphillips@google.com40a1ae42012-07-13 15:36:15 +0000437
reed@google.comac10a2d2010-12-22 21:39:39 +0000438 if (fNeedPrepareRenderTarget ||
bsalomon@google.com5782d712011-01-21 21:03:59 +0000439 fContext->getRenderTarget() != fRenderTarget) {
reed@google.comac10a2d2010-12-22 21:39:39 +0000440
441 fContext->setRenderTarget(fRenderTarget);
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000442 SkASSERT(draw.fClipStack && draw.fClipStack == fClipData.fClipStack);
robertphillips@google.com607fe072012-07-24 13:54:00 +0000443
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000444 set_matrix_and_clip(fContext, *draw.fMatrix,
445 fClipData, *draw.fClip, this->getOrigin(),
446 fRenderTarget->width(), fRenderTarget->height());
reed@google.comac10a2d2010-12-22 21:39:39 +0000447 fNeedPrepareRenderTarget = false;
448 }
449}
450
tomhudson@google.com8a0b0292011-09-13 14:41:06 +0000451void SkGpuDevice::setMatrixClip(const SkMatrix& matrix, const SkRegion& clip,
452 const SkClipStack& clipStack) {
453 this->INHERITED::setMatrixClip(matrix, clip, clipStack);
454 // We don't need to set them now because the context may not reflect this device.
bsalomon@google.coma7bf6e22011-04-11 19:20:46 +0000455 fNeedPrepareRenderTarget = true;
reed@google.comac10a2d2010-12-22 21:39:39 +0000456}
457
robertphillips@google.com40a1ae42012-07-13 15:36:15 +0000458void SkGpuDevice::gainFocus(const SkMatrix& matrix, const SkRegion& clip) {
459
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000460 GrAssert(NULL != fClipData.fClipStack);
bsalomon@google.comd302f142011-03-03 13:54:13 +0000461
reed@google.comac10a2d2010-12-22 21:39:39 +0000462 fContext->setRenderTarget(fRenderTarget);
463
robertphillips@google.com40a1ae42012-07-13 15:36:15 +0000464 this->INHERITED::gainFocus(matrix, clip);
reed@google.comac10a2d2010-12-22 21:39:39 +0000465
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000466 set_matrix_and_clip(fContext, matrix, fClipData, clip, this->getOrigin(),
467 fRenderTarget->width(), fRenderTarget->height());
reed@google.comac10a2d2010-12-22 21:39:39 +0000468
bsalomon@google.com06cd7322012-03-30 18:45:35 +0000469 DO_DEFERRED_CLEAR;
reed@google.comac10a2d2010-12-22 21:39:39 +0000470}
471
vandebo@chromium.org74b46192012-01-28 01:45:11 +0000472SkGpuRenderTarget* SkGpuDevice::accessRenderTarget() {
bsalomon@google.com06cd7322012-03-30 18:45:35 +0000473 DO_DEFERRED_CLEAR;
vandebo@chromium.org74b46192012-01-28 01:45:11 +0000474 return (SkGpuRenderTarget*)fRenderTarget;
reed@google.com75d939b2011-12-07 15:07:23 +0000475}
476
bsalomon@google.comc6cf7232011-02-17 16:43:10 +0000477bool SkGpuDevice::bindDeviceAsTexture(GrPaint* paint) {
bsalomon@google.coma2921122012-08-28 12:34:17 +0000478 GrTexture* texture = fRenderTarget->asTexture();
479 if (NULL != texture) {
bsalomon@google.com1c31f632012-07-26 19:39:06 +0000480 paint->textureSampler(kBitmapTextureIdx)->setCustomStage(
bsalomon@google.coma2921122012-08-28 12:34:17 +0000481 SkNEW_ARGS(GrSingleTextureEffect, (texture)))->unref();
reed@google.comac10a2d2010-12-22 21:39:39 +0000482 return true;
483 }
484 return false;
485}
486
487///////////////////////////////////////////////////////////////////////////////
488
vandebo@chromium.orgd3ae7792011-02-24 00:21:06 +0000489SK_COMPILE_ASSERT(SkShader::kNone_BitmapType == 0, shader_type_mismatch);
490SK_COMPILE_ASSERT(SkShader::kDefault_BitmapType == 1, shader_type_mismatch);
491SK_COMPILE_ASSERT(SkShader::kRadial_BitmapType == 2, shader_type_mismatch);
492SK_COMPILE_ASSERT(SkShader::kSweep_BitmapType == 3, shader_type_mismatch);
493SK_COMPILE_ASSERT(SkShader::kTwoPointRadial_BitmapType == 4,
494 shader_type_mismatch);
rileya@google.com3e332582012-07-03 13:43:35 +0000495SK_COMPILE_ASSERT(SkShader::kTwoPointConical_BitmapType == 5,
496 shader_type_mismatch);
rileya@google.com22e57f92012-07-19 15:16:19 +0000497SK_COMPILE_ASSERT(SkShader::kLinear_BitmapType == 6, shader_type_mismatch);
498SK_COMPILE_ASSERT(SkShader::kLast_BitmapType == 6, shader_type_mismatch);
reed@google.comac10a2d2010-12-22 21:39:39 +0000499
bsalomon@google.com84405e02012-03-05 19:57:21 +0000500namespace {
501
502// converts a SkPaint to a GrPaint, ignoring the skPaint's shader
503// justAlpha indicates that skPaint's alpha should be used rather than the color
504// Callers may subsequently modify the GrPaint. Setting constantColor indicates
505// that the final paint will draw the same color at every pixel. This allows
506// an optimization where the the color filter can be applied to the skPaint's
twiz@google.com58071162012-07-18 21:41:50 +0000507// color once while converting to GrPaint and then ignored.
508inline bool skPaint2GrPaintNoShader(SkGpuDevice* dev,
509 const SkPaint& skPaint,
bsalomon@google.com84405e02012-03-05 19:57:21 +0000510 bool justAlpha,
511 bool constantColor,
twiz@google.com58071162012-07-18 21:41:50 +0000512 SkGpuDevice::SkAutoCachedTexture* act,
bsalomon@google.com84405e02012-03-05 19:57:21 +0000513 GrPaint* grPaint) {
bsalomon@google.com5782d712011-01-21 21:03:59 +0000514
515 grPaint->fDither = skPaint.isDither();
516 grPaint->fAntiAlias = skPaint.isAntiAlias();
bsalomon@google.comdd1be602012-01-18 20:34:00 +0000517 grPaint->fCoverage = 0xFF;
bsalomon@google.com5782d712011-01-21 21:03:59 +0000518
bsalomon@google.com88939ae2011-12-14 15:58:11 +0000519 SkXfermode::Coeff sm = SkXfermode::kOne_Coeff;
520 SkXfermode::Coeff dm = SkXfermode::kISA_Coeff;
bsalomon@google.com5782d712011-01-21 21:03:59 +0000521
522 SkXfermode* mode = skPaint.getXfermode();
523 if (mode) {
524 if (!mode->asCoeff(&sm, &dm)) {
bsalomon@google.com979432b2011-11-05 21:38:22 +0000525 //SkDEBUGCODE(SkDebugf("Unsupported xfer mode.\n");)
bsalomon@google.com5782d712011-01-21 21:03:59 +0000526#if 0
527 return false;
528#endif
529 }
530 }
bsalomon@google.com88939ae2011-12-14 15:58:11 +0000531 grPaint->fSrcBlendCoeff = sk_blend_to_grblend(sm);
532 grPaint->fDstBlendCoeff = sk_blend_to_grblend(dm);
533
bsalomon@google.com5782d712011-01-21 21:03:59 +0000534 if (justAlpha) {
535 uint8_t alpha = skPaint.getAlpha();
536 grPaint->fColor = GrColorPackRGBA(alpha, alpha, alpha, alpha);
Scroggod757df22011-05-16 13:11:16 +0000537 // justAlpha is currently set to true only if there is a texture,
538 // so constantColor should not also be true.
539 GrAssert(!constantColor);
bsalomon@google.com5782d712011-01-21 21:03:59 +0000540 } else {
rileya@google.com24f3ad12012-07-18 21:47:40 +0000541 grPaint->fColor = SkColor2GrColor(skPaint.getColor());
bsalomon@google.com1c31f632012-07-26 19:39:06 +0000542 GrAssert(!grPaint->isTextureStageEnabled(kShaderTextureIdx));
bsalomon@google.com5782d712011-01-21 21:03:59 +0000543 }
Scroggo97c88c22011-05-11 14:05:25 +0000544 SkColorFilter* colorFilter = skPaint.getColorFilter();
545 SkColor color;
546 SkXfermode::Mode filterMode;
senorblanco@chromium.org50bdad82012-01-03 20:51:57 +0000547 SkScalar matrix[20];
twiz@google.com58071162012-07-18 21:41:50 +0000548 SkBitmap colorTransformTable;
bsalomon@google.com0d944822012-08-16 15:06:57 +0000549 grPaint->resetColorFilter();
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +0000550 // TODO: SkColorFilter::asCustomStage()
Scroggo97c88c22011-05-11 14:05:25 +0000551 if (colorFilter != NULL && colorFilter->asColorMode(&color, &filterMode)) {
senorblanco@chromium.org50bdad82012-01-03 20:51:57 +0000552 grPaint->fColorMatrixEnabled = false;
Scroggod757df22011-05-16 13:11:16 +0000553 if (!constantColor) {
rileya@google.com24f3ad12012-07-18 21:47:40 +0000554 grPaint->fColorFilterColor = SkColor2GrColor(color);
Scroggod757df22011-05-16 13:11:16 +0000555 grPaint->fColorFilterXfermode = filterMode;
senorblanco@chromium.org50bdad82012-01-03 20:51:57 +0000556 } else {
557 SkColor filtered = colorFilter->filterColor(skPaint.getColor());
rileya@google.com24f3ad12012-07-18 21:47:40 +0000558 grPaint->fColor = SkColor2GrColor(filtered);
Scroggod757df22011-05-16 13:11:16 +0000559 }
senorblanco@chromium.org50bdad82012-01-03 20:51:57 +0000560 } else if (colorFilter != NULL && colorFilter->asColorMatrix(matrix)) {
561 grPaint->fColorMatrixEnabled = true;
562 memcpy(grPaint->fColorMatrix, matrix, sizeof(matrix));
563 grPaint->fColorFilterXfermode = SkXfermode::kDst_Mode;
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +0000564 } else if (colorFilter != NULL && colorFilter->asComponentTable(&colorTransformTable)) {
twiz@google.com58071162012-07-18 21:41:50 +0000565 grPaint->resetColorFilter();
566
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +0000567 // pass NULL because the color table effect doesn't use tiling or filtering.
568 GrTexture* texture = act->set(dev, colorTransformTable, NULL);
twiz@google.com58071162012-07-18 21:41:50 +0000569 GrSamplerState* colorSampler = grPaint->textureSampler(kColorFilterTextureIdx);
bsalomon@google.comb8670992012-07-25 21:27:09 +0000570 colorSampler->reset();
bsalomon@google.comcbd0ad92012-07-20 15:09:31 +0000571 colorSampler->setCustomStage(SkNEW_ARGS(GrColorTableEffect, (texture)))->unref();
Scroggo97c88c22011-05-11 14:05:25 +0000572 }
bsalomon@google.com5782d712011-01-21 21:03:59 +0000573 return true;
reed@google.comac10a2d2010-12-22 21:39:39 +0000574}
575
bsalomon@google.com84405e02012-03-05 19:57:21 +0000576// This function is similar to skPaint2GrPaintNoShader but also converts
577// skPaint's shader to a GrTexture/GrSamplerState if possible. The texture to
578// be used is set on grPaint and returned in param act. constantColor has the
579// same meaning as in skPaint2GrPaintNoShader.
580inline bool skPaint2GrPaintShader(SkGpuDevice* dev,
581 const SkPaint& skPaint,
bsalomon@google.com84405e02012-03-05 19:57:21 +0000582 bool constantColor,
twiz@google.com58071162012-07-18 21:41:50 +0000583 SkGpuDevice::SkAutoCachedTexture textures[GrPaint::kMaxTextures],
bsalomon@google.com84405e02012-03-05 19:57:21 +0000584 GrPaint* grPaint) {
bsalomon@google.com5782d712011-01-21 21:03:59 +0000585 SkShader* shader = skPaint.getShader();
reed@google.comac10a2d2010-12-22 21:39:39 +0000586 if (NULL == shader) {
twiz@google.com58071162012-07-18 21:41:50 +0000587 return skPaint2GrPaintNoShader(dev,
588 skPaint,
bsalomon@google.com84405e02012-03-05 19:57:21 +0000589 false,
590 constantColor,
twiz@google.com58071162012-07-18 21:41:50 +0000591 &textures[kColorFilterTextureIdx],
bsalomon@google.com84405e02012-03-05 19:57:21 +0000592 grPaint);
rmistry@google.comd6176b02012-08-23 18:14:13 +0000593 } else if (!skPaint2GrPaintNoShader(dev, skPaint, true, false,
twiz@google.com58071162012-07-18 21:41:50 +0000594 &textures[kColorFilterTextureIdx], grPaint)) {
bsalomon@google.com5782d712011-01-21 21:03:59 +0000595 return false;
reed@google.comac10a2d2010-12-22 21:39:39 +0000596 }
597
rileya@google.com91f319c2012-07-25 17:18:31 +0000598 GrSamplerState* sampler = grPaint->textureSampler(kShaderTextureIdx);
599 GrCustomStage* stage = shader->asNewCustomStage(dev->context(), sampler);
600
601 if (NULL != stage) {
602 sampler->setCustomStage(stage)->unref();
603 SkMatrix localM;
604 if (shader->getLocalMatrix(&localM)) {
605 SkMatrix inverse;
606 if (localM.invert(&inverse)) {
607 sampler->matrix()->preConcat(inverse);
608 }
609 }
610 return true;
611 }
612
reed@google.comac10a2d2010-12-22 21:39:39 +0000613 SkBitmap bitmap;
rileya@google.com91f319c2012-07-25 17:18:31 +0000614 SkMatrix* matrix = sampler->matrix();
reed@google.comac10a2d2010-12-22 21:39:39 +0000615 SkShader::TileMode tileModes[2];
bsalomon@google.comaa814fe2011-12-12 18:45:07 +0000616 SkShader::BitmapType bmptype = shader->asABitmap(&bitmap, matrix,
rileya@google.com91f319c2012-07-25 17:18:31 +0000617 tileModes);
reed@google.comac10a2d2010-12-22 21:39:39 +0000618
tomhudson@google.com898e7b52012-06-01 20:42:15 +0000619 if (SkShader::kNone_BitmapType == bmptype) {
reed@google.com2be9e8b2011-07-06 21:18:09 +0000620 SkShader::GradientInfo info;
621 SkColor color;
622
623 info.fColors = &color;
624 info.fColorOffsets = NULL;
625 info.fColorCount = 1;
626 if (SkShader::kColor_GradientType == shader->asAGradient(&info)) {
627 SkPaint copy(skPaint);
628 copy.setShader(NULL);
bsalomon@google.comcd9cfd72011-07-08 16:55:04 +0000629 // modulate the paint alpha by the shader's solid color alpha
630 U8CPU newA = SkMulDiv255Round(SkColorGetA(color), copy.getAlpha());
631 copy.setColor(SkColorSetA(color, newA));
twiz@google.com58071162012-07-18 21:41:50 +0000632 return skPaint2GrPaintNoShader(dev,
633 copy,
bsalomon@google.com84405e02012-03-05 19:57:21 +0000634 false,
635 constantColor,
twiz@google.com58071162012-07-18 21:41:50 +0000636 &textures[kColorFilterTextureIdx],
bsalomon@google.com84405e02012-03-05 19:57:21 +0000637 grPaint);
reed@google.com2be9e8b2011-07-06 21:18:09 +0000638 }
bsalomon@google.com5782d712011-01-21 21:03:59 +0000639 return false;
reed@google.comac10a2d2010-12-22 21:39:39 +0000640 }
tomhudson@google.comd0c1a062012-07-12 17:23:52 +0000641
bsalomon@google.com8f4fdc92012-07-24 17:59:01 +0000642 // Must set wrap and filter on the sampler before requesting a texture.
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +0000643 GrTextureParams params(tileModes, skPaint.isFilterBitmap());
644 GrTexture* texture = textures[kShaderTextureIdx].set(dev, bitmap, &params);
bsalomon@google.com8f4fdc92012-07-24 17:59:01 +0000645
tomhudson@google.comd0c1a062012-07-12 17:23:52 +0000646 if (NULL == texture) {
647 SkDebugf("Couldn't convert bitmap to texture.\n");
648 return false;
649 }
tomhudson@google.comd0c1a062012-07-12 17:23:52 +0000650
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +0000651 sampler->reset();
652 sampler->setCustomStage(SkNEW_ARGS(GrSingleTextureEffect, (texture, params)))->unref();
reed@google.comac10a2d2010-12-22 21:39:39 +0000653
reed@google.comac10a2d2010-12-22 21:39:39 +0000654 // since our texture coords will be in local space, we wack the texture
655 // matrix to map them back into 0...1 before we load it
656 SkMatrix localM;
657 if (shader->getLocalMatrix(&localM)) {
658 SkMatrix inverse;
659 if (localM.invert(&inverse)) {
bsalomon@google.comaa814fe2011-12-12 18:45:07 +0000660 matrix->preConcat(inverse);
reed@google.comac10a2d2010-12-22 21:39:39 +0000661 }
662 }
663 if (SkShader::kDefault_BitmapType == bmptype) {
bsalomon@google.com91832162012-03-08 19:53:02 +0000664 GrScalar sx = SkFloatToScalar(1.f / bitmap.width());
665 GrScalar sy = SkFloatToScalar(1.f / bitmap.height());
bsalomon@google.comaa814fe2011-12-12 18:45:07 +0000666 matrix->postScale(sx, sy);
reed@google.comac10a2d2010-12-22 21:39:39 +0000667 }
bsalomon@google.com5782d712011-01-21 21:03:59 +0000668
669 return true;
reed@google.comac10a2d2010-12-22 21:39:39 +0000670}
bsalomon@google.com84405e02012-03-05 19:57:21 +0000671}
reed@google.comac10a2d2010-12-22 21:39:39 +0000672
673///////////////////////////////////////////////////////////////////////////////
bsalomon@google.com398109c2011-04-14 18:40:27 +0000674void SkGpuDevice::clear(SkColor color) {
robertphillips@google.comc82a8b72012-06-21 20:15:48 +0000675 fContext->clear(NULL, color, fRenderTarget);
bsalomon@google.com398109c2011-04-14 18:40:27 +0000676}
677
reed@google.comac10a2d2010-12-22 21:39:39 +0000678void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
679 CHECK_SHOULD_DRAW(draw);
680
bsalomon@google.com5782d712011-01-21 21:03:59 +0000681 GrPaint grPaint;
twiz@google.com58071162012-07-18 21:41:50 +0000682 SkAutoCachedTexture textures[GrPaint::kMaxTextures];
bsalomon@google.com84405e02012-03-05 19:57:21 +0000683 if (!skPaint2GrPaintShader(this,
684 paint,
bsalomon@google.com84405e02012-03-05 19:57:21 +0000685 true,
twiz@google.com58071162012-07-18 21:41:50 +0000686 textures,
bsalomon@google.com84405e02012-03-05 19:57:21 +0000687 &grPaint)) {
reed@google.comac10a2d2010-12-22 21:39:39 +0000688 return;
689 }
bsalomon@google.com5782d712011-01-21 21:03:59 +0000690
691 fContext->drawPaint(grPaint);
reed@google.comac10a2d2010-12-22 21:39:39 +0000692}
693
694// must be in SkCanvas::PointMode order
bsalomon@google.comffca4002011-02-22 20:34:01 +0000695static const GrPrimitiveType gPointMode2PrimtiveType[] = {
bsalomon@google.com47059542012-06-06 20:51:20 +0000696 kPoints_GrPrimitiveType,
697 kLines_GrPrimitiveType,
698 kLineStrip_GrPrimitiveType
reed@google.comac10a2d2010-12-22 21:39:39 +0000699};
700
701void SkGpuDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode,
bsalomon@google.com5782d712011-01-21 21:03:59 +0000702 size_t count, const SkPoint pts[], const SkPaint& paint) {
reed@google.comac10a2d2010-12-22 21:39:39 +0000703 CHECK_SHOULD_DRAW(draw);
704
705 SkScalar width = paint.getStrokeWidth();
706 if (width < 0) {
707 return;
708 }
709
bsalomon@google.comb702c0f2012-06-18 12:52:56 +0000710 // we only handle hairlines and paints without path effects or mask filters,
711 // else we let the SkDraw call our drawPath()
712 if (width > 0 || paint.getPathEffect() || paint.getMaskFilter()) {
reed@google.comac10a2d2010-12-22 21:39:39 +0000713 draw.drawPoints(mode, count, pts, paint, true);
714 return;
715 }
716
bsalomon@google.com5782d712011-01-21 21:03:59 +0000717 GrPaint grPaint;
twiz@google.com58071162012-07-18 21:41:50 +0000718 SkAutoCachedTexture textures[GrPaint::kMaxTextures];
bsalomon@google.com84405e02012-03-05 19:57:21 +0000719 if (!skPaint2GrPaintShader(this,
720 paint,
bsalomon@google.com84405e02012-03-05 19:57:21 +0000721 true,
twiz@google.com58071162012-07-18 21:41:50 +0000722 textures,
bsalomon@google.com84405e02012-03-05 19:57:21 +0000723 &grPaint)) {
reed@google.comac10a2d2010-12-22 21:39:39 +0000724 return;
725 }
726
bsalomon@google.com5782d712011-01-21 21:03:59 +0000727 fContext->drawVertices(grPaint,
728 gPointMode2PrimtiveType[mode],
729 count,
730 (GrPoint*)pts,
731 NULL,
732 NULL,
733 NULL,
734 0);
reed@google.comac10a2d2010-12-22 21:39:39 +0000735}
736
reed@google.comc9aa5872011-04-05 21:05:37 +0000737///////////////////////////////////////////////////////////////////////////////
738
reed@google.comac10a2d2010-12-22 21:39:39 +0000739void SkGpuDevice::drawRect(const SkDraw& draw, const SkRect& rect,
740 const SkPaint& paint) {
reed@google.comb0a34d82012-07-11 19:57:55 +0000741 CHECK_FOR_NODRAW_ANNOTATION(paint);
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000742 CHECK_SHOULD_DRAW(draw);
743
bungeman@google.com79bd8772011-07-18 15:34:08 +0000744 bool doStroke = paint.getStyle() != SkPaint::kFill_Style;
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000745 SkScalar width = paint.getStrokeWidth();
746
747 /*
748 We have special code for hairline strokes, miter-strokes, and fills.
749 Anything else we just call our path code.
750 */
751 bool usePath = doStroke && width > 0 &&
752 paint.getStrokeJoin() != SkPaint::kMiter_Join;
bsalomon@google.com22f42b72012-03-26 14:36:55 +0000753 // another two reasons we might need to call drawPath...
754 if (paint.getMaskFilter() || paint.getPathEffect()) {
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000755 usePath = true;
756 }
reed@google.com67db6642011-05-26 11:46:35 +0000757 // until we aa rotated rects...
758 if (!usePath && paint.isAntiAlias() && !draw.fMatrix->rectStaysRect()) {
759 usePath = true;
760 }
bungeman@google.com633722e2011-08-09 18:32:51 +0000761 // small miter limit means right angles show bevel...
762 if (SkPaint::kMiter_Join == paint.getStrokeJoin() &&
763 paint.getStrokeMiter() < SK_ScalarSqrt2)
764 {
765 usePath = true;
766 }
bungeman@google.com79bd8772011-07-18 15:34:08 +0000767 // until we can both stroke and fill rectangles
bungeman@google.com79bd8772011-07-18 15:34:08 +0000768 if (paint.getStyle() == SkPaint::kStrokeAndFill_Style) {
769 usePath = true;
770 }
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000771
772 if (usePath) {
773 SkPath path;
774 path.addRect(rect);
775 this->drawPath(draw, path, paint, NULL, true);
776 return;
777 }
778
779 GrPaint grPaint;
twiz@google.com58071162012-07-18 21:41:50 +0000780 SkAutoCachedTexture textures[GrPaint::kMaxTextures];
bsalomon@google.com84405e02012-03-05 19:57:21 +0000781 if (!skPaint2GrPaintShader(this,
782 paint,
bsalomon@google.com84405e02012-03-05 19:57:21 +0000783 true,
twiz@google.com58071162012-07-18 21:41:50 +0000784 textures,
bsalomon@google.com84405e02012-03-05 19:57:21 +0000785 &grPaint)) {
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000786 return;
787 }
reed@google.com20efde72011-05-09 17:00:02 +0000788 fContext->drawRect(grPaint, rect, doStroke ? width : -1);
reed@google.comac10a2d2010-12-22 21:39:39 +0000789}
790
reed@google.com69302852011-02-16 18:08:07 +0000791#include "SkMaskFilter.h"
792#include "SkBounder.h"
793
bsalomon@google.com85003222012-03-28 14:44:37 +0000794///////////////////////////////////////////////////////////////////////////////
795
796// helpers for applying mask filters
797namespace {
798
799GrPathFill skToGrFillType(SkPath::FillType fillType) {
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000800 switch (fillType) {
801 case SkPath::kWinding_FillType:
bsalomon@google.com47059542012-06-06 20:51:20 +0000802 return kWinding_GrPathFill;
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000803 case SkPath::kEvenOdd_FillType:
bsalomon@google.com47059542012-06-06 20:51:20 +0000804 return kEvenOdd_GrPathFill;
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000805 case SkPath::kInverseWinding_FillType:
bsalomon@google.com47059542012-06-06 20:51:20 +0000806 return kInverseWinding_GrPathFill;
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000807 case SkPath::kInverseEvenOdd_FillType:
bsalomon@google.com47059542012-06-06 20:51:20 +0000808 return kInverseEvenOdd_GrPathFill;
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000809 default:
810 SkDebugf("Unsupported path fill type\n");
bsalomon@google.com47059542012-06-06 20:51:20 +0000811 return kHairLine_GrPathFill;
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000812 }
813}
814
bsalomon@google.com85003222012-03-28 14:44:37 +0000815// We prefer to blur small rect with small radius via CPU.
816#define MIN_GPU_BLUR_SIZE SkIntToScalar(64)
817#define MIN_GPU_BLUR_RADIUS SkIntToScalar(32)
818inline bool shouldDrawBlurWithCPU(const SkRect& rect, SkScalar radius) {
819 if (rect.width() <= MIN_GPU_BLUR_SIZE &&
820 rect.height() <= MIN_GPU_BLUR_SIZE &&
821 radius <= MIN_GPU_BLUR_RADIUS) {
822 return true;
823 }
824 return false;
825}
826
827bool drawWithGPUMaskFilter(GrContext* context, const SkPath& path,
828 SkMaskFilter* filter, const SkMatrix& matrix,
829 const SkRegion& clip, SkBounder* bounder,
junov@chromium.orgaad7e272012-04-04 21:01:08 +0000830 GrPaint* grp, GrPathFill pathFillType) {
senorblanco@chromium.orga479fc72011-07-19 16:40:58 +0000831#ifdef SK_DISABLE_GPU_BLUR
senorblanco@chromium.orgaadd9f82011-07-12 19:44:51 +0000832 return false;
senorblanco@chromium.orgb08ea1b2011-07-12 16:54:59 +0000833#endif
senorblanco@chromium.orgaadd9f82011-07-12 19:44:51 +0000834 SkMaskFilter::BlurInfo info;
835 SkMaskFilter::BlurType blurType = filter->asABlur(&info);
bsalomon@google.comdafde9e2012-01-11 18:45:39 +0000836 if (SkMaskFilter::kNone_BlurType == blurType) {
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000837 return false;
838 }
senorblanco@chromium.orge36ddf02011-07-15 14:28:16 +0000839 SkScalar radius = info.fIgnoreTransform ? info.fRadius
840 : matrix.mapRadius(info.fRadius);
841 radius = SkMinScalar(radius, MAX_BLUR_RADIUS);
senorblanco@chromium.org68c4d122011-08-01 21:20:31 +0000842 if (radius <= 0) {
843 return false;
844 }
bsalomon@google.com85003222012-03-28 14:44:37 +0000845
846 SkRect srcRect = path.getBounds();
847 if (shouldDrawBlurWithCPU(srcRect, radius)) {
848 return false;
849 }
850
senorblanco@chromium.orge36ddf02011-07-15 14:28:16 +0000851 float sigma = SkScalarToFloat(radius) * BLUR_SIGMA_SCALE;
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +0000852 float sigma3 = sigma * 3.0f;
853
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +0000854 SkRect clipRect;
855 clipRect.set(clip.getBounds());
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000856
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +0000857 // Outset srcRect and clipRect by 3 * sigma, to compute affected blur area.
robertphillips@google.com5af56062012-04-27 15:39:52 +0000858 srcRect.inset(SkFloatToScalar(-sigma3), SkFloatToScalar(-sigma3));
859 clipRect.inset(SkFloatToScalar(-sigma3), SkFloatToScalar(-sigma3));
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +0000860 srcRect.intersect(clipRect);
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000861 SkRect finalRect = srcRect;
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000862 SkIRect finalIRect;
863 finalRect.roundOut(&finalIRect);
864 if (clip.quickReject(finalIRect)) {
senorblanco@chromium.orgaadd9f82011-07-12 19:44:51 +0000865 return true;
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000866 }
867 if (bounder && !bounder->doIRect(finalIRect)) {
senorblanco@chromium.orgaadd9f82011-07-12 19:44:51 +0000868 return true;
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000869 }
870 GrPoint offset = GrPoint::Make(-srcRect.fLeft, -srcRect.fTop);
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +0000871 srcRect.offset(offset);
robertphillips@google.com75b3c962012-06-07 12:08:45 +0000872 GrTextureDesc desc;
873 desc.fFlags = kRenderTarget_GrTextureFlagBit;
874 desc.fWidth = SkScalarCeilToInt(srcRect.width());
875 desc.fHeight = SkScalarCeilToInt(srcRect.height());
876 // We actually only need A8, but it often isn't supported as a
877 // render target so default to RGBA_8888
bsalomon@google.com0342a852012-08-20 19:22:38 +0000878 desc.fConfig = kRGBA_8888_GrPixelConfig;
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000879
robertphillips@google.com99a5ac02012-04-10 19:26:38 +0000880 if (context->isConfigRenderable(kAlpha_8_GrPixelConfig)) {
881 desc.fConfig = kAlpha_8_GrPixelConfig;
882 }
883
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +0000884 GrAutoScratchTexture pathEntry(context, desc);
885 GrTexture* pathTexture = pathEntry.texture();
886 if (NULL == pathTexture) {
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000887 return false;
888 }
889 GrRenderTarget* oldRenderTarget = context->getRenderTarget();
senorblanco@chromium.org42dd0f92011-07-14 15:29:57 +0000890 // Once this code moves into GrContext, this should be changed to use
891 // an AutoClipRestore.
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000892 const GrClipData* oldClipData = context->getClip();
893
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +0000894 context->setRenderTarget(pathTexture->asRenderTarget());
robertphillips@google.com3e11c0b2012-07-11 18:20:35 +0000895
robertphillips@google.com641f8b12012-07-31 19:15:58 +0000896 SkClipStack newClipStack(srcRect);
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000897 GrClipData newClipData;
898 newClipData.fClipStack = &newClipStack;
899 context->setClip(&newClipData);
robertphillips@google.com3e11c0b2012-07-11 18:20:35 +0000900
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000901 context->clear(NULL, 0);
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000902 GrPaint tempPaint;
903 tempPaint.reset();
904
robertphillips@google.comfea85ac2012-07-11 18:53:23 +0000905 GrContext::AutoMatrix avm(context, GrMatrix::I());
senorblanco@chromium.orgb08ea1b2011-07-12 16:54:59 +0000906 tempPaint.fAntiAlias = grp->fAntiAlias;
907 if (tempPaint.fAntiAlias) {
908 // AA uses the "coverage" stages on GrDrawTarget. Coverage with a dst
909 // blend coeff of zero requires dual source blending support in order
910 // to properly blend partially covered pixels. This means the AA
911 // code path may not be taken. So we use a dst blend coeff of ISA. We
912 // could special case AA draws to a dst surface with known alpha=0 to
913 // use a zero dst coeff when dual source blending isn't available.
bsalomon@google.com47059542012-06-06 20:51:20 +0000914 tempPaint.fSrcBlendCoeff = kOne_GrBlendCoeff;
915 tempPaint.fDstBlendCoeff = kISC_GrBlendCoeff;
senorblanco@chromium.orgb08ea1b2011-07-12 16:54:59 +0000916 }
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +0000917 // Draw hard shadow to pathTexture with path topleft at origin 0,0.
junov@chromium.orgaad7e272012-04-04 21:01:08 +0000918 context->drawPath(tempPaint, path, pathFillType, &offset);
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000919
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +0000920 // If we're doing a normal blur, we can clobber the pathTexture in the
921 // gaussianBlur. Otherwise, we need to save it for later compositing.
922 bool isNormalBlur = blurType == SkMaskFilter::kNormal_BlurType;
senorblanco@chromium.org1e95d712012-07-18 19:52:53 +0000923 SkAutoTUnref<GrTexture> blurTexture(context->gaussianBlur(
924 pathTexture, isNormalBlur, srcRect, sigma, sigma));
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000925
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +0000926 if (!isNormalBlur) {
927 GrPaint paint;
928 paint.reset();
bsalomon@google.comaa814fe2011-12-12 18:45:07 +0000929 paint.textureSampler(0)->matrix()->setIDiv(pathTexture->width(),
930 pathTexture->height());
senorblanco@chromium.org60014ca2011-11-09 16:05:58 +0000931 // Blend pathTexture over blurTexture.
932 context->setRenderTarget(blurTexture->asRenderTarget());
tomhudson@google.com1e8f0162012-07-20 16:25:18 +0000933 paint.textureSampler(0)->setCustomStage(SkNEW_ARGS
934 (GrSingleTextureEffect, (pathTexture)))->unref();
senorblanco@chromium.orgb08ea1b2011-07-12 16:54:59 +0000935 if (SkMaskFilter::kInner_BlurType == blurType) {
936 // inner: dst = dst * src
bsalomon@google.com47059542012-06-06 20:51:20 +0000937 paint.fSrcBlendCoeff = kDC_GrBlendCoeff;
938 paint.fDstBlendCoeff = kZero_GrBlendCoeff;
senorblanco@chromium.orgb08ea1b2011-07-12 16:54:59 +0000939 } else if (SkMaskFilter::kSolid_BlurType == blurType) {
940 // solid: dst = src + dst - src * dst
941 // = (1 - dst) * src + 1 * dst
bsalomon@google.com47059542012-06-06 20:51:20 +0000942 paint.fSrcBlendCoeff = kIDC_GrBlendCoeff;
943 paint.fDstBlendCoeff = kOne_GrBlendCoeff;
senorblanco@chromium.orgb08ea1b2011-07-12 16:54:59 +0000944 } else if (SkMaskFilter::kOuter_BlurType == blurType) {
945 // outer: dst = dst * (1 - src)
946 // = 0 * src + (1 - src) * dst
bsalomon@google.com47059542012-06-06 20:51:20 +0000947 paint.fSrcBlendCoeff = kZero_GrBlendCoeff;
948 paint.fDstBlendCoeff = kISC_GrBlendCoeff;
senorblanco@chromium.orgb08ea1b2011-07-12 16:54:59 +0000949 }
950 context->drawRect(paint, srcRect);
951 }
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000952 context->setRenderTarget(oldRenderTarget);
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000953 context->setClip(oldClipData);
vandebo@chromium.org74b46192012-01-28 01:45:11 +0000954
bsalomon@google.come3d32162012-07-20 13:37:06 +0000955 if (!grp->preConcatSamplerMatricesWithInverse(matrix)) {
956 return false;
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000957 }
958
959 static const int MASK_IDX = GrPaint::kMaxMasks - 1;
960 // we assume the last mask index is available for use
tomhudson@google.comf13f5882012-06-25 17:27:28 +0000961 GrAssert(!grp->isMaskStageEnabled(MASK_IDX));
bsalomon@google.com97912912011-12-06 16:30:36 +0000962 grp->maskSampler(MASK_IDX)->reset();
bsalomon@google.com1c31f632012-07-26 19:39:06 +0000963 grp->maskSampler(MASK_IDX)->setCustomStage(
964 SkNEW_ARGS(GrSingleTextureEffect, (blurTexture)))->unref();
bsalomon@google.comaa814fe2011-12-12 18:45:07 +0000965 grp->maskSampler(MASK_IDX)->matrix()->setTranslate(-finalRect.fLeft,
966 -finalRect.fTop);
967 grp->maskSampler(MASK_IDX)->matrix()->postIDiv(blurTexture->width(),
968 blurTexture->height());
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000969 context->drawRect(*grp, finalRect);
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +0000970 return true;
971}
972
bsalomon@google.com85003222012-03-28 14:44:37 +0000973bool drawWithMaskFilter(GrContext* context, const SkPath& path,
974 SkMaskFilter* filter, const SkMatrix& matrix,
975 const SkRegion& clip, SkBounder* bounder,
junov@chromium.orgaad7e272012-04-04 21:01:08 +0000976 GrPaint* grp, SkPaint::Style style) {
reed@google.com69302852011-02-16 18:08:07 +0000977 SkMask srcM, dstM;
978
979 if (!SkDraw::DrawToMask(path, &clip.getBounds(), filter, &matrix, &srcM,
junov@chromium.org2ac4ef52012-04-04 15:16:51 +0000980 SkMask::kComputeBoundsAndRenderImage_CreateMode,
junov@chromium.orgaad7e272012-04-04 21:01:08 +0000981 style)) {
reed@google.com69302852011-02-16 18:08:07 +0000982 return false;
983 }
bungeman@google.com02f55842011-10-04 21:25:00 +0000984 SkAutoMaskFreeImage autoSrc(srcM.fImage);
reed@google.com69302852011-02-16 18:08:07 +0000985
986 if (!filter->filterMask(&dstM, srcM, matrix, NULL)) {
987 return false;
988 }
989 // this will free-up dstM when we're done (allocated in filterMask())
bungeman@google.com02f55842011-10-04 21:25:00 +0000990 SkAutoMaskFreeImage autoDst(dstM.fImage);
reed@google.com69302852011-02-16 18:08:07 +0000991
992 if (clip.quickReject(dstM.fBounds)) {
993 return false;
994 }
995 if (bounder && !bounder->doIRect(dstM.fBounds)) {
996 return false;
997 }
998
999 // we now have a device-aligned 8bit mask in dstM, ready to be drawn using
1000 // the current clip (and identity matrix) and grpaint settings
1001
robertphillips@google.comfea85ac2012-07-11 18:53:23 +00001002 GrContext::AutoMatrix avm(context, GrMatrix::I());
reed@google.com69302852011-02-16 18:08:07 +00001003
bsalomon@google.come3d32162012-07-20 13:37:06 +00001004 if (!grp->preConcatSamplerMatricesWithInverse(matrix)) {
1005 return false;
1006 }
1007
robertphillips@google.com75b3c962012-06-07 12:08:45 +00001008 GrTextureDesc desc;
1009 desc.fWidth = dstM.fBounds.width();
1010 desc.fHeight = dstM.fBounds.height();
1011 desc.fConfig = kAlpha_8_GrPixelConfig;
reed@google.com69302852011-02-16 18:08:07 +00001012
bsalomon@google.com50398bf2011-07-26 20:45:30 +00001013 GrAutoScratchTexture ast(context, desc);
1014 GrTexture* texture = ast.texture();
bsalomon@google.comeb2aa1d2011-07-14 15:45:19 +00001015
reed@google.com69302852011-02-16 18:08:07 +00001016 if (NULL == texture) {
1017 return false;
1018 }
bsalomon@google.com6f379512011-11-16 20:36:03 +00001019 texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
bsalomon@google.comeb2aa1d2011-07-14 15:45:19 +00001020 dstM.fImage, dstM.fRowBytes);
reed@google.com69302852011-02-16 18:08:07 +00001021
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +00001022 static const int MASK_IDX = GrPaint::kMaxMasks - 1;
1023 // we assume the last mask index is available for use
tomhudson@google.comf13f5882012-06-25 17:27:28 +00001024 GrAssert(!grp->isMaskStageEnabled(MASK_IDX));
bsalomon@google.com97912912011-12-06 16:30:36 +00001025 grp->maskSampler(MASK_IDX)->reset();
bsalomon@google.com1c31f632012-07-26 19:39:06 +00001026 grp->maskSampler(MASK_IDX)->setCustomStage(
1027 SkNEW_ARGS(GrSingleTextureEffect, (texture)))->unref();
bsalomon@google.comc6cf7232011-02-17 16:43:10 +00001028 GrRect d;
1029 d.setLTRB(GrIntToScalar(dstM.fBounds.fLeft),
reed@google.com0c219b62011-02-16 21:31:18 +00001030 GrIntToScalar(dstM.fBounds.fTop),
1031 GrIntToScalar(dstM.fBounds.fRight),
1032 GrIntToScalar(dstM.fBounds.fBottom));
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +00001033
bsalomon@google.comaa814fe2011-12-12 18:45:07 +00001034 GrMatrix* m = grp->maskSampler(MASK_IDX)->matrix();
1035 m->setTranslate(-dstM.fBounds.fLeft*SK_Scalar1,
1036 -dstM.fBounds.fTop*SK_Scalar1);
1037 m->postIDiv(texture->width(), texture->height());
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +00001038 context->drawRect(*grp, d);
reed@google.com69302852011-02-16 18:08:07 +00001039 return true;
1040}
reed@google.com69302852011-02-16 18:08:07 +00001041
bsalomon@google.com85003222012-03-28 14:44:37 +00001042}
1043
1044///////////////////////////////////////////////////////////////////////////////
1045
reed@google.com0c219b62011-02-16 21:31:18 +00001046void SkGpuDevice::drawPath(const SkDraw& draw, const SkPath& origSrcPath,
bsalomon@google.comdd1be602012-01-18 20:34:00 +00001047 const SkPaint& paint, const SkMatrix* prePathMatrix,
reed@google.comac10a2d2010-12-22 21:39:39 +00001048 bool pathIsMutable) {
reed@google.comb0a34d82012-07-11 19:57:55 +00001049 CHECK_FOR_NODRAW_ANNOTATION(paint);
reed@google.comac10a2d2010-12-22 21:39:39 +00001050 CHECK_SHOULD_DRAW(draw);
1051
reed@google.comfe626382011-09-21 13:50:35 +00001052 bool doFill = true;
bsalomon@google.comdd1be602012-01-18 20:34:00 +00001053
bsalomon@google.com5782d712011-01-21 21:03:59 +00001054 GrPaint grPaint;
twiz@google.com58071162012-07-18 21:41:50 +00001055 SkAutoCachedTexture textures[GrPaint::kMaxTextures];
bsalomon@google.com84405e02012-03-05 19:57:21 +00001056 if (!skPaint2GrPaintShader(this,
1057 paint,
bsalomon@google.com84405e02012-03-05 19:57:21 +00001058 true,
twiz@google.com58071162012-07-18 21:41:50 +00001059 textures,
bsalomon@google.com84405e02012-03-05 19:57:21 +00001060 &grPaint)) {
reed@google.comac10a2d2010-12-22 21:39:39 +00001061 return;
1062 }
1063
bsalomon@google.com8c0a0d32012-03-05 16:01:18 +00001064 // can we cheat, and threat a thin stroke as a hairline w/ coverage
1065 // if we can, we draw lots faster (raster device does this same test)
1066 SkScalar hairlineCoverage;
1067 if (SkDrawTreatAsHairline(paint, *draw.fMatrix, &hairlineCoverage)) {
1068 doFill = false;
1069 grPaint.fCoverage = SkScalarRoundToInt(hairlineCoverage *
1070 grPaint.fCoverage);
1071 }
bsalomon@google.comdd1be602012-01-18 20:34:00 +00001072
reed@google.comfe626382011-09-21 13:50:35 +00001073 // If we have a prematrix, apply it to the path, optimizing for the case
1074 // where the original path can in fact be modified in place (even though
1075 // its parameter type is const).
1076 SkPath* pathPtr = const_cast<SkPath*>(&origSrcPath);
1077 SkPath tmpPath;
reed@google.comac10a2d2010-12-22 21:39:39 +00001078
1079 if (prePathMatrix) {
reed@google.come3445642011-02-16 23:20:39 +00001080 SkPath* result = pathPtr;
reed@google.com0c219b62011-02-16 21:31:18 +00001081
reed@google.come3445642011-02-16 23:20:39 +00001082 if (!pathIsMutable) {
1083 result = &tmpPath;
1084 pathIsMutable = true;
reed@google.comac10a2d2010-12-22 21:39:39 +00001085 }
reed@google.come3445642011-02-16 23:20:39 +00001086 // should I push prePathMatrix on our MV stack temporarily, instead
1087 // of applying it here? See SkDraw.cpp
1088 pathPtr->transform(*prePathMatrix, result);
1089 pathPtr = result;
reed@google.comac10a2d2010-12-22 21:39:39 +00001090 }
reed@google.com0c219b62011-02-16 21:31:18 +00001091 // at this point we're done with prePathMatrix
1092 SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)
reed@google.comac10a2d2010-12-22 21:39:39 +00001093
bsalomon@google.com8b58c4d2012-02-13 14:49:09 +00001094 if (paint.getPathEffect() ||
1095 (doFill && paint.getStyle() != SkPaint::kFill_Style)) {
reed@google.comfe626382011-09-21 13:50:35 +00001096 // it is safe to use tmpPath here, even if we already used it for the
1097 // prepathmatrix, since getFillPath can take the same object for its
1098 // input and output safely.
bsalomon@google.comdd1be602012-01-18 20:34:00 +00001099 doFill = paint.getFillPath(*pathPtr, &tmpPath);
reed@google.com0c219b62011-02-16 21:31:18 +00001100 pathPtr = &tmpPath;
1101 }
1102
bsalomon@google.comdd1be602012-01-18 20:34:00 +00001103 if (paint.getMaskFilter()) {
reed@google.com0c219b62011-02-16 21:31:18 +00001104 // avoid possibly allocating a new path in transform if we can
1105 SkPath* devPathPtr = pathIsMutable ? pathPtr : &tmpPath;
1106
1107 // transform the path into device space
reed@google.come3445642011-02-16 23:20:39 +00001108 pathPtr->transform(*draw.fMatrix, devPathPtr);
junov@chromium.orgaad7e272012-04-04 21:01:08 +00001109 GrPathFill pathFillType = doFill ?
bsalomon@google.com47059542012-06-06 20:51:20 +00001110 skToGrFillType(devPathPtr->getFillType()) : kHairLine_GrPathFill;
bsalomon@google.comdd1be602012-01-18 20:34:00 +00001111 if (!drawWithGPUMaskFilter(fContext, *devPathPtr, paint.getMaskFilter(),
senorblanco@chromium.orgb08ea1b2011-07-12 16:54:59 +00001112 *draw.fMatrix, *draw.fClip, draw.fBounder,
junov@chromium.orgaad7e272012-04-04 21:01:08 +00001113 &grPaint, pathFillType)) {
rmistry@google.comd6176b02012-08-23 18:14:13 +00001114 SkPaint::Style style = doFill ? SkPaint::kFill_Style :
junov@chromium.orgaad7e272012-04-04 21:01:08 +00001115 SkPaint::kStroke_Style;
bsalomon@google.comdd1be602012-01-18 20:34:00 +00001116 drawWithMaskFilter(fContext, *devPathPtr, paint.getMaskFilter(),
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +00001117 *draw.fMatrix, *draw.fClip, draw.fBounder,
junov@chromium.orgaad7e272012-04-04 21:01:08 +00001118 &grPaint, style);
senorblanco@chromium.org027de5f2011-07-08 18:03:33 +00001119 }
reed@google.com69302852011-02-16 18:08:07 +00001120 return;
1121 }
reed@google.com69302852011-02-16 18:08:07 +00001122
bsalomon@google.com47059542012-06-06 20:51:20 +00001123 GrPathFill fill = kHairLine_GrPathFill;
reed@google.comac10a2d2010-12-22 21:39:39 +00001124
reed@google.com0c219b62011-02-16 21:31:18 +00001125 if (doFill) {
1126 switch (pathPtr->getFillType()) {
reed@google.comac10a2d2010-12-22 21:39:39 +00001127 case SkPath::kWinding_FillType:
bsalomon@google.com47059542012-06-06 20:51:20 +00001128 fill = kWinding_GrPathFill;
reed@google.comac10a2d2010-12-22 21:39:39 +00001129 break;
1130 case SkPath::kEvenOdd_FillType:
bsalomon@google.com47059542012-06-06 20:51:20 +00001131 fill = kEvenOdd_GrPathFill;
reed@google.comac10a2d2010-12-22 21:39:39 +00001132 break;
1133 case SkPath::kInverseWinding_FillType:
bsalomon@google.com47059542012-06-06 20:51:20 +00001134 fill = kInverseWinding_GrPathFill;
reed@google.comac10a2d2010-12-22 21:39:39 +00001135 break;
1136 case SkPath::kInverseEvenOdd_FillType:
bsalomon@google.com47059542012-06-06 20:51:20 +00001137 fill = kInverseEvenOdd_GrPathFill;
reed@google.comac10a2d2010-12-22 21:39:39 +00001138 break;
1139 default:
bsalomon@google.com5782d712011-01-21 21:03:59 +00001140 SkDebugf("Unsupported path fill type\n");
reed@google.comac10a2d2010-12-22 21:39:39 +00001141 return;
1142 }
1143 }
1144
reed@google.com07f3ee12011-05-16 17:21:57 +00001145 fContext->drawPath(grPaint, *pathPtr, fill);
reed@google.comac10a2d2010-12-22 21:39:39 +00001146}
1147
bsalomon@google.comfb309512011-11-30 14:13:48 +00001148namespace {
1149
1150inline int get_tile_count(int l, int t, int r, int b, int tileSize) {
1151 int tilesX = (r / tileSize) - (l / tileSize) + 1;
1152 int tilesY = (b / tileSize) - (t / tileSize) + 1;
1153 return tilesX * tilesY;
1154}
1155
vandebo@chromium.org74b46192012-01-28 01:45:11 +00001156inline int determine_tile_size(const SkBitmap& bitmap,
robertphillips@google.combac6b052012-09-28 18:06:49 +00001157 const SkRect& src,
bsalomon@google.comfb309512011-11-30 14:13:48 +00001158 int maxTextureSize) {
1159 static const int kSmallTileSize = 1 << 10;
1160 if (maxTextureSize <= kSmallTileSize) {
1161 return maxTextureSize;
1162 }
1163
1164 size_t maxTexTotalTileSize;
1165 size_t smallTotalTileSize;
1166
robertphillips@google.combac6b052012-09-28 18:06:49 +00001167 SkIRect iSrc;
1168 src.roundOut(&iSrc);
1169
1170 maxTexTotalTileSize = get_tile_count(iSrc.fLeft,
1171 iSrc.fTop,
1172 iSrc.fRight,
1173 iSrc.fBottom,
1174 maxTextureSize);
1175 smallTotalTileSize = get_tile_count(iSrc.fLeft,
1176 iSrc.fTop,
1177 iSrc.fRight,
1178 iSrc.fBottom,
1179 kSmallTileSize);
1180
bsalomon@google.comfb309512011-11-30 14:13:48 +00001181 maxTexTotalTileSize *= maxTextureSize * maxTextureSize;
1182 smallTotalTileSize *= kSmallTileSize * kSmallTileSize;
1183
1184 if (maxTexTotalTileSize > 2 * smallTotalTileSize) {
1185 return kSmallTileSize;
1186 } else {
1187 return maxTextureSize;
1188 }
1189}
1190}
1191
1192bool SkGpuDevice::shouldTileBitmap(const SkBitmap& bitmap,
bsalomon@google.comb8670992012-07-25 21:27:09 +00001193 const GrTextureParams& params,
robertphillips@google.combac6b052012-09-28 18:06:49 +00001194 const SkRect* srcRectPtr) const {
bsalomon@google.comfb309512011-11-30 14:13:48 +00001195 // if bitmap is explictly texture backed then just use the texture
1196 if (NULL != bitmap.getTexture()) {
1197 return false;
1198 }
1199 // if it's larger than the max texture size, then we have no choice but
1200 // tiling
1201 const int maxTextureSize = fContext->getMaxTextureSize();
1202 if (bitmap.width() > maxTextureSize ||
1203 bitmap.height() > maxTextureSize) {
bsalomon@google.comfb309512011-11-30 14:13:48 +00001204 return true;
1205 }
1206 // if we are going to have to draw the whole thing, then don't tile
1207 if (NULL == srcRectPtr) {
1208 return false;
1209 }
1210 // if the entire texture is already in our cache then no reason to tile it
bsalomon@google.comb8670992012-07-25 21:27:09 +00001211 if (this->isBitmapInTextureCache(bitmap, params)) {
bsalomon@google.comfb309512011-11-30 14:13:48 +00001212 return false;
1213 }
1214
1215 // At this point we know we could do the draw by uploading the entire bitmap
1216 // as a texture. However, if the texture would be large compared to the
1217 // cache size and we don't require most of it for this draw then tile to
1218 // reduce the amount of upload and cache spill.
1219
1220 // assumption here is that sw bitmap size is a good proxy for its size as
1221 // a texture
1222 size_t bmpSize = bitmap.getSize();
bsalomon@google.com07fc0d12012-06-22 15:15:59 +00001223 size_t cacheSize;
1224 fContext->getTextureCacheLimits(NULL, &cacheSize);
bsalomon@google.comfb309512011-11-30 14:13:48 +00001225 if (bmpSize < cacheSize / 2) {
1226 return false;
1227 }
1228
robertphillips@google.combac6b052012-09-28 18:06:49 +00001229 SkScalar fracUsed = SkScalarMul(srcRectPtr->width() / bitmap.width(),
1230 srcRectPtr->height() / bitmap.height());
1231 if (fracUsed <= SK_ScalarHalf) {
bsalomon@google.comfb309512011-11-30 14:13:48 +00001232 return true;
1233 } else {
1234 return false;
1235 }
1236}
1237
reed@google.comac10a2d2010-12-22 21:39:39 +00001238void SkGpuDevice::drawBitmap(const SkDraw& draw,
1239 const SkBitmap& bitmap,
1240 const SkIRect* srcRectPtr,
1241 const SkMatrix& m,
1242 const SkPaint& paint) {
robertphillips@google.combac6b052012-09-28 18:06:49 +00001243
1244 SkRect tmp;
1245 SkRect* tmpPtr = NULL;
1246
1247 // convert from SkIRect to SkRect
1248 if (NULL != srcRectPtr) {
1249 tmp.set(*srcRectPtr);
1250 tmpPtr = &tmp;
1251 }
1252
1253 // We cannot call drawBitmapRect here since 'm' could be anything
1254 this->drawBitmapCommon(draw, bitmap, tmpPtr, m, paint);
1255}
1256
1257void SkGpuDevice::drawBitmapCommon(const SkDraw& draw,
1258 const SkBitmap& bitmap,
1259 const SkRect* srcRectPtr,
1260 const SkMatrix& m,
1261 const SkPaint& paint) {
reed@google.comac10a2d2010-12-22 21:39:39 +00001262 CHECK_SHOULD_DRAW(draw);
1263
robertphillips@google.combac6b052012-09-28 18:06:49 +00001264 SkRect srcRect;
reed@google.comac10a2d2010-12-22 21:39:39 +00001265 if (NULL == srcRectPtr) {
robertphillips@google.combac6b052012-09-28 18:06:49 +00001266 srcRect.set(0, 0, SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height()));
reed@google.comac10a2d2010-12-22 21:39:39 +00001267 } else {
1268 srcRect = *srcRectPtr;
1269 }
1270
junov@google.comd935cfb2011-06-27 20:48:23 +00001271 if (paint.getMaskFilter()){
junov@google.com1d329782011-07-28 20:10:09 +00001272 // Convert the bitmap to a shader so that the rect can be drawn
1273 // through drawRect, which supports mask filters.
robertphillips@google.combac6b052012-09-28 18:06:49 +00001274 SkMatrix newM(m);
junov@google.com1d329782011-07-28 20:10:09 +00001275 SkBitmap tmp; // subset of bitmap, if necessary
junov@google.comd935cfb2011-06-27 20:48:23 +00001276 const SkBitmap* bitmapPtr = &bitmap;
robertphillips@google.combac6b052012-09-28 18:06:49 +00001277 if (NULL != srcRectPtr) {
1278 SkIRect iSrc;
1279 srcRect.roundOut(&iSrc);
1280 if (!bitmap.extractSubset(&tmp, iSrc)) {
epoger@google.com9ef2d832011-07-01 21:12:20 +00001281 return; // extraction failed
1282 }
1283 bitmapPtr = &tmp;
robertphillips@google.combac6b052012-09-28 18:06:49 +00001284 srcRect.offset(SkIntToScalar(-iSrc.fLeft), SkIntToScalar(-iSrc.fTop));
1285 // The source rect has changed so update the matrix
1286 newM.preTranslate(SkIntToScalar(iSrc.fLeft), SkIntToScalar(iSrc.fTop));
junov@google.comd935cfb2011-06-27 20:48:23 +00001287 }
robertphillips@google.combac6b052012-09-28 18:06:49 +00001288
junov@google.comd935cfb2011-06-27 20:48:23 +00001289 SkPaint paintWithTexture(paint);
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001290 paintWithTexture.setShader(SkShader::CreateBitmapShader(*bitmapPtr,
junov@google.comd935cfb2011-06-27 20:48:23 +00001291 SkShader::kClamp_TileMode, SkShader::kClamp_TileMode))->unref();
junov@google.comd935cfb2011-06-27 20:48:23 +00001292
robertphillips@google.combac6b052012-09-28 18:06:49 +00001293 // Transform 'newM' needs to be concatenated to the draw matrix,
1294 // rather than transforming the primitive directly, so that 'newM' will
junov@google.com1d329782011-07-28 20:10:09 +00001295 // also affect the behavior of the mask filter.
1296 SkMatrix drawMatrix;
robertphillips@google.combac6b052012-09-28 18:06:49 +00001297 drawMatrix.setConcat(*draw.fMatrix, newM);
junov@google.com1d329782011-07-28 20:10:09 +00001298 SkDraw transformedDraw(draw);
1299 transformedDraw.fMatrix = &drawMatrix;
1300
robertphillips@google.combac6b052012-09-28 18:06:49 +00001301 this->drawRect(transformedDraw, srcRect, paintWithTexture);
junov@google.com1d329782011-07-28 20:10:09 +00001302
junov@google.comd935cfb2011-06-27 20:48:23 +00001303 return;
1304 }
1305
bsalomon@google.com5782d712011-01-21 21:03:59 +00001306 GrPaint grPaint;
twiz@google.com58071162012-07-18 21:41:50 +00001307 SkAutoCachedTexture colorLutTexture;
1308 if (!skPaint2GrPaintNoShader(this, paint, true, false, &colorLutTexture, &grPaint)) {
bsalomon@google.com5782d712011-01-21 21:03:59 +00001309 return;
1310 }
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001311 GrTextureParams params;
1312 params.setBilerp(paint.isFilterBitmap());
bsalomon@google.com5782d712011-01-21 21:03:59 +00001313
robertphillips@google.combac6b052012-09-28 18:06:49 +00001314 if (!this->shouldTileBitmap(bitmap, params, srcRectPtr)) {
bsalomon@google.comfb309512011-11-30 14:13:48 +00001315 // take the simple case
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001316 this->internalDrawBitmap(draw, bitmap, srcRect, m, params, &grPaint);
robertphillips@google.combac6b052012-09-28 18:06:49 +00001317 } else {
1318 this->drawTiledBitmap(draw, bitmap, srcRect, m, params, &grPaint);
reed@google.comac10a2d2010-12-22 21:39:39 +00001319 }
robertphillips@google.combac6b052012-09-28 18:06:49 +00001320}
1321
1322// Break 'bitmap' into several tiles to draw it since it has already
1323// been determined to be too large to fit in VRAM
1324void SkGpuDevice::drawTiledBitmap(const SkDraw& draw,
1325 const SkBitmap& bitmap,
1326 const SkRect& srcRect,
1327 const SkMatrix& m,
1328 const GrTextureParams& params,
1329 GrPaint* grPaint) {
1330 const int maxTextureSize = fContext->getMaxTextureSize();
1331
1332 int tileSize = determine_tile_size(bitmap, srcRect, maxTextureSize);
reed@google.comac10a2d2010-12-22 21:39:39 +00001333
1334 // undo the translate done by SkCanvas
robertphillips@google.combac6b052012-09-28 18:06:49 +00001335 SkScalar DX = SkMaxScalar(0, srcRect.fLeft);
1336 SkScalar DY = SkMaxScalar(0, srcRect.fTop);
reed@google.comac10a2d2010-12-22 21:39:39 +00001337 // compute clip bounds in local coordinates
robertphillips@google.combac6b052012-09-28 18:06:49 +00001338 SkRect clipRect;
reed@google.comac10a2d2010-12-22 21:39:39 +00001339 {
robertphillips@google.combac6b052012-09-28 18:06:49 +00001340 clipRect.set(draw.fClip->getBounds());
reed@google.comac10a2d2010-12-22 21:39:39 +00001341 SkMatrix matrix, inverse;
1342 matrix.setConcat(*draw.fMatrix, m);
1343 if (!matrix.invert(&inverse)) {
1344 return;
1345 }
robertphillips@google.combac6b052012-09-28 18:06:49 +00001346 inverse.mapRect(&clipRect);
reed@google.comac10a2d2010-12-22 21:39:39 +00001347 // apply the canvas' translate to our local clip
1348 clipRect.offset(DX, DY);
1349 }
1350
bsalomon@google.comfb309512011-11-30 14:13:48 +00001351 int nx = bitmap.width() / tileSize;
1352 int ny = bitmap.height() / tileSize;
reed@google.comac10a2d2010-12-22 21:39:39 +00001353 for (int x = 0; x <= nx; x++) {
1354 for (int y = 0; y <= ny; y++) {
robertphillips@google.combac6b052012-09-28 18:06:49 +00001355 SkRect tileR;
1356 tileR.set(SkIntToScalar(x * tileSize),
1357 SkIntToScalar(y * tileSize),
1358 SkIntToScalar((x + 1) * tileSize),
1359 SkIntToScalar((y + 1) * tileSize));
1360
1361 if (!SkRect::Intersects(tileR, clipRect)) {
reed@google.comac10a2d2010-12-22 21:39:39 +00001362 continue;
1363 }
1364
robertphillips@google.combac6b052012-09-28 18:06:49 +00001365 if (!tileR.intersect(srcRect)) {
reed@google.comac10a2d2010-12-22 21:39:39 +00001366 continue;
1367 }
1368
1369 SkBitmap tmpB;
robertphillips@google.combac6b052012-09-28 18:06:49 +00001370 SkIRect iTileR;
1371 tileR.roundOut(&iTileR);
1372 if (bitmap.extractSubset(&tmpB, iTileR)) {
reed@google.comac10a2d2010-12-22 21:39:39 +00001373 // now offset it to make it "local" to our tmp bitmap
robertphillips@google.combac6b052012-09-28 18:06:49 +00001374 tileR.offset(SkIntToScalar(-iTileR.fLeft), SkIntToScalar(-iTileR.fTop));
reed@google.comac10a2d2010-12-22 21:39:39 +00001375
1376 SkMatrix tmpM(m);
1377 {
robertphillips@google.combac6b052012-09-28 18:06:49 +00001378 SkScalar dx = iTileR.fLeft - DX + SkMaxScalar(0, tileR.fLeft);
1379 SkScalar dy = iTileR.fTop - DY + SkMaxScalar(0, tileR.fTop);
1380 tmpM.preTranslate(dx, dy);
reed@google.comac10a2d2010-12-22 21:39:39 +00001381 }
robertphillips@google.combac6b052012-09-28 18:06:49 +00001382 this->internalDrawBitmap(draw, tmpB, tileR, tmpM, params, grPaint);
reed@google.comac10a2d2010-12-22 21:39:39 +00001383 }
1384 }
1385 }
1386}
1387
junov@chromium.orgf32a9b62012-03-16 20:54:17 +00001388namespace {
1389
1390bool hasAlignedSamples(const SkRect& srcRect, const SkRect& transformedRect) {
1391 // detect pixel disalignment
1392 if (SkScalarAbs(SkScalarRoundToScalar(transformedRect.left()) -
1393 transformedRect.left()) < COLOR_BLEED_TOLERANCE &&
rmistry@google.comd6176b02012-08-23 18:14:13 +00001394 SkScalarAbs(SkScalarRoundToScalar(transformedRect.top()) -
junov@chromium.orgf32a9b62012-03-16 20:54:17 +00001395 transformedRect.top()) < COLOR_BLEED_TOLERANCE &&
1396 SkScalarAbs(transformedRect.width() - srcRect.width()) <
1397 COLOR_BLEED_TOLERANCE &&
1398 SkScalarAbs(transformedRect.height() - srcRect.height()) <
1399 COLOR_BLEED_TOLERANCE) {
1400 return true;
1401 }
1402 return false;
1403}
1404
1405bool mayColorBleed(const SkRect& srcRect, const SkRect& transformedRect,
1406 const SkMatrix& m) {
1407 // Only gets called if hasAlignedSamples returned false.
1408 // So we can assume that sampling is axis aligned but not texel aligned.
1409 GrAssert(!hasAlignedSamples(srcRect, transformedRect));
rmistry@google.comd6176b02012-08-23 18:14:13 +00001410 SkRect innerSrcRect(srcRect), innerTransformedRect,
junov@chromium.orgf32a9b62012-03-16 20:54:17 +00001411 outerTransformedRect(transformedRect);
1412 innerSrcRect.inset(SK_ScalarHalf, SK_ScalarHalf);
1413 m.mapRect(&innerTransformedRect, innerSrcRect);
1414
1415 // The gap between outerTransformedRect and innerTransformedRect
1416 // represents the projection of the source border area, which is
1417 // problematic for color bleeding. We must check whether any
1418 // destination pixels sample the border area.
1419 outerTransformedRect.inset(COLOR_BLEED_TOLERANCE, COLOR_BLEED_TOLERANCE);
1420 innerTransformedRect.outset(COLOR_BLEED_TOLERANCE, COLOR_BLEED_TOLERANCE);
1421 SkIRect outer, inner;
1422 outerTransformedRect.round(&outer);
1423 innerTransformedRect.round(&inner);
1424 // If the inner and outer rects round to the same result, it means the
1425 // border does not overlap any pixel centers. Yay!
1426 return inner != outer;
1427}
1428
1429} // unnamed namespace
1430
reed@google.comac10a2d2010-12-22 21:39:39 +00001431/*
1432 * This is called by drawBitmap(), which has to handle images that may be too
1433 * large to be represented by a single texture.
1434 *
bsalomon@google.com5782d712011-01-21 21:03:59 +00001435 * internalDrawBitmap assumes that the specified bitmap will fit in a texture
1436 * and that non-texture portion of the GrPaint has already been setup.
reed@google.comac10a2d2010-12-22 21:39:39 +00001437 */
1438void SkGpuDevice::internalDrawBitmap(const SkDraw& draw,
1439 const SkBitmap& bitmap,
robertphillips@google.combac6b052012-09-28 18:06:49 +00001440 const SkRect& srcRect,
reed@google.comac10a2d2010-12-22 21:39:39 +00001441 const SkMatrix& m,
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001442 const GrTextureParams& params,
bsalomon@google.com5782d712011-01-21 21:03:59 +00001443 GrPaint* grPaint) {
bsalomon@google.com91958362011-06-13 17:58:13 +00001444 SkASSERT(bitmap.width() <= fContext->getMaxTextureSize() &&
1445 bitmap.height() <= fContext->getMaxTextureSize());
reed@google.comac10a2d2010-12-22 21:39:39 +00001446
reed@google.com9c49bc32011-07-07 13:42:37 +00001447 SkAutoLockPixels alp(bitmap, !bitmap.getTexture());
reed@google.comac10a2d2010-12-22 21:39:39 +00001448 if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
reed@google.com9c49bc32011-07-07 13:42:37 +00001449 SkDebugf("nothing to draw\n");
reed@google.comac10a2d2010-12-22 21:39:39 +00001450 return;
1451 }
1452
bsalomon@google.com39ee0ff2011-12-06 15:32:52 +00001453 GrSamplerState* sampler = grPaint->textureSampler(kBitmapTextureIdx);
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +00001454
bsalomon@google.comaa814fe2011-12-12 18:45:07 +00001455 sampler->matrix()->reset();
reed@google.comac10a2d2010-12-22 21:39:39 +00001456
1457 GrTexture* texture;
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001458 SkAutoCachedTexture act(this, bitmap, &params, &texture);
reed@google.comac10a2d2010-12-22 21:39:39 +00001459 if (NULL == texture) {
1460 return;
1461 }
1462
robertphillips@google.combac6b052012-09-28 18:06:49 +00001463 GrRect dstRect(srcRect);
bsalomon@google.comc6cf7232011-02-17 16:43:10 +00001464 GrRect paintRect;
robertphillips@google.combac6b052012-09-28 18:06:49 +00001465 SkScalar wInv = SkScalarInvert(SkIntToScalar(bitmap.width()));
1466 SkScalar hInv = SkScalarInvert(SkIntToScalar(bitmap.height()));
1467 paintRect.setLTRB(SkScalarMul(srcRect.fLeft, wInv),
1468 SkScalarMul(srcRect.fTop, hInv),
1469 SkScalarMul(srcRect.fRight, wInv),
1470 SkScalarMul(srcRect.fBottom, hInv));
reed@google.comac10a2d2010-12-22 21:39:39 +00001471
rmistry@google.comd6176b02012-08-23 18:14:13 +00001472 bool needsTextureDomain = false;
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001473 if (params.isBilerp()) {
junov@chromium.orgf32a9b62012-03-16 20:54:17 +00001474 // Need texture domain if drawing a sub rect.
robertphillips@google.combac6b052012-09-28 18:06:49 +00001475 needsTextureDomain = srcRect.width() < bitmap.width() ||
1476 srcRect.height() < bitmap.height();
junov@chromium.orgf32a9b62012-03-16 20:54:17 +00001477 if (m.rectStaysRect() && draw.fMatrix->rectStaysRect()) {
1478 // sampling is axis-aligned
robertphillips@google.combac6b052012-09-28 18:06:49 +00001479 GrRect transformedRect;
junov@chromium.orgf32a9b62012-03-16 20:54:17 +00001480 SkMatrix srcToDeviceMatrix(m);
1481 srcToDeviceMatrix.postConcat(*draw.fMatrix);
robertphillips@google.combac6b052012-09-28 18:06:49 +00001482 srcToDeviceMatrix.mapRect(&transformedRect, srcRect);
rmistry@google.comd6176b02012-08-23 18:14:13 +00001483
robertphillips@google.combac6b052012-09-28 18:06:49 +00001484 if (hasAlignedSamples(srcRect, transformedRect)) {
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001485 // We could also turn off filtering here (but we already did a cache lookup with
1486 // params).
junov@chromium.orgf32a9b62012-03-16 20:54:17 +00001487 needsTextureDomain = false;
1488 } else {
1489 needsTextureDomain = needsTextureDomain &&
robertphillips@google.combac6b052012-09-28 18:06:49 +00001490 mayColorBleed(srcRect, transformedRect, m);
junov@chromium.orgf32a9b62012-03-16 20:54:17 +00001491 }
1492 }
rmistry@google.comd6176b02012-08-23 18:14:13 +00001493 }
junov@chromium.orgf32a9b62012-03-16 20:54:17 +00001494
1495 GrRect textureDomain = GrRect::MakeEmpty();
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001496 SkAutoTUnref<GrCustomStage> stage;
junov@chromium.orgf32a9b62012-03-16 20:54:17 +00001497 if (needsTextureDomain) {
1498 // Use a constrained texture domain to avoid color bleeding
junov@google.com6acc9b32011-05-16 18:32:07 +00001499 GrScalar left, top, right, bottom;
robertphillips@google.combac6b052012-09-28 18:06:49 +00001500 if (srcRect.width() > GR_Scalar1) {
junov@google.com6acc9b32011-05-16 18:32:07 +00001501 GrScalar border = GR_ScalarHalf / bitmap.width();
1502 left = paintRect.left() + border;
1503 right = paintRect.right() - border;
1504 } else {
1505 left = right = GrScalarHalf(paintRect.left() + paintRect.right());
1506 }
robertphillips@google.combac6b052012-09-28 18:06:49 +00001507 if (srcRect.height() > GR_Scalar1) {
junov@google.com6acc9b32011-05-16 18:32:07 +00001508 GrScalar border = GR_ScalarHalf / bitmap.height();
1509 top = paintRect.top() + border;
1510 bottom = paintRect.bottom() - border;
1511 } else {
1512 top = bottom = GrScalarHalf(paintRect.top() + paintRect.bottom());
1513 }
rmistry@google.comd6176b02012-08-23 18:14:13 +00001514 textureDomain.setLTRB(left, top, right, bottom);
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001515 stage.reset(SkNEW_ARGS(GrTextureDomainEffect, (texture, textureDomain, params)));
1516 } else {
1517 stage.reset(SkNEW_ARGS(GrSingleTextureEffect, (texture, params)));
junov@google.com6acc9b32011-05-16 18:32:07 +00001518 }
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001519 grPaint->textureSampler(kBitmapTextureIdx)->setCustomStage(stage);
bsalomon@google.comcc4dac32011-05-10 13:52:42 +00001520 fContext->drawRectToRect(*grPaint, dstRect, paintRect, &m);
reed@google.comac10a2d2010-12-22 21:39:39 +00001521}
1522
senorblanco@chromium.org894790d2012-07-11 16:01:22 +00001523namespace {
1524
1525void apply_custom_stage(GrContext* context,
1526 GrTexture* srcTexture,
1527 GrTexture* dstTexture,
1528 const GrRect& rect,
1529 GrCustomStage* stage) {
1530 SkASSERT(srcTexture && srcTexture->getContext() == context);
robertphillips@google.comfea85ac2012-07-11 18:53:23 +00001531 GrContext::AutoMatrix avm(context, GrMatrix::I());
senorblanco@chromium.org894790d2012-07-11 16:01:22 +00001532 GrContext::AutoRenderTarget art(context, dstTexture->asRenderTarget());
robertphillips@google.com56c79b12012-07-11 20:57:46 +00001533 GrContext::AutoClip acs(context, rect);
senorblanco@chromium.org894790d2012-07-11 16:01:22 +00001534
1535 GrMatrix sampleM;
1536 sampleM.setIDiv(srcTexture->width(), srcTexture->height());
1537 GrPaint paint;
1538 paint.reset();
senorblanco@chromium.org894790d2012-07-11 16:01:22 +00001539 paint.textureSampler(0)->reset(sampleM);
1540 paint.textureSampler(0)->setCustomStage(stage);
senorblanco@chromium.org894790d2012-07-11 16:01:22 +00001541 context->drawRect(paint, rect);
senorblanco@chromium.org894790d2012-07-11 16:01:22 +00001542}
1543
1544};
1545
senorblanco@chromium.org9c397442012-09-27 21:57:45 +00001546static GrTexture* filter_texture(SkDevice* device, GrContext* context,
1547 GrTexture* texture, SkImageFilter* filter,
1548 const GrRect& rect) {
reed@google.com8926b162012-03-23 15:36:36 +00001549 GrAssert(filter);
senorblanco@chromium.org9c397442012-09-27 21:57:45 +00001550 SkDeviceImageFilterProxy proxy(device);
reed@google.com8926b162012-03-23 15:36:36 +00001551
robertphillips@google.com75b3c962012-06-07 12:08:45 +00001552 GrTextureDesc desc;
1553 desc.fFlags = kRenderTarget_GrTextureFlagBit,
1554 desc.fWidth = SkScalarCeilToInt(rect.width());
1555 desc.fHeight = SkScalarCeilToInt(rect.height());
bsalomon@google.com0342a852012-08-20 19:22:38 +00001556 desc.fConfig = kRGBA_8888_GrPixelConfig;
senorblanco@chromium.org894790d2012-07-11 16:01:22 +00001557 GrCustomStage* stage;
reed@google.com8926b162012-03-23 15:36:36 +00001558
senorblanco@chromium.org302cffb2012-08-01 20:16:34 +00001559 if (filter->canFilterImageGPU()) {
senorblanco@chromium.org9c397442012-09-27 21:57:45 +00001560 texture = filter->onFilterImageGPU(&proxy, texture, rect);
senorblanco@chromium.org302cffb2012-08-01 20:16:34 +00001561 } else if (filter->asNewCustomStage(&stage, texture)) {
senorblanco@chromium.org894790d2012-07-11 16:01:22 +00001562 GrAutoScratchTexture dst(context, desc);
1563 apply_custom_stage(context, texture, dst.texture(), rect, stage);
1564 texture = dst.detach();
1565 stage->unref();
reed@google.com8926b162012-03-23 15:36:36 +00001566 }
1567 return texture;
1568}
1569
reed@google.comac10a2d2010-12-22 21:39:39 +00001570void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
1571 int left, int top, const SkPaint& paint) {
1572 CHECK_SHOULD_DRAW(draw);
1573
reed@google.com8926b162012-03-23 15:36:36 +00001574 SkAutoLockPixels alp(bitmap, !bitmap.getTexture());
reed@google.comac10a2d2010-12-22 21:39:39 +00001575 if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
1576 return;
1577 }
1578
reed@google.com76dd2772012-01-05 21:15:07 +00001579 int w = bitmap.width();
1580 int h = bitmap.height();
1581
bsalomon@google.com5782d712011-01-21 21:03:59 +00001582 GrPaint grPaint;
twiz@google.com58071162012-07-18 21:41:50 +00001583 SkAutoCachedTexture colorLutTexture;
1584 if(!skPaint2GrPaintNoShader(this, paint, true, false, &colorLutTexture, &grPaint)) {
bsalomon@google.com5782d712011-01-21 21:03:59 +00001585 return;
1586 }
reed@google.comac10a2d2010-12-22 21:39:39 +00001587
robertphillips@google.comfea85ac2012-07-11 18:53:23 +00001588 GrContext::AutoMatrix avm(fContext, GrMatrix::I());
bsalomon@google.com5782d712011-01-21 21:03:59 +00001589
bsalomon@google.com39ee0ff2011-12-06 15:32:52 +00001590 GrSamplerState* sampler = grPaint.textureSampler(kBitmapTextureIdx);
bsalomon@google.com5782d712011-01-21 21:03:59 +00001591
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +00001592 GrTexture* texture;
bsalomon@google.com97912912011-12-06 16:30:36 +00001593 sampler->reset();
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001594 // draw sprite uses the default texture params
1595 SkAutoCachedTexture act(this, bitmap, NULL, &texture);
tomhudson@google.com1e8f0162012-07-20 16:25:18 +00001596 grPaint.textureSampler(kBitmapTextureIdx)->setCustomStage(SkNEW_ARGS
1597 (GrSingleTextureEffect, (texture)))->unref();
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +00001598
reed@google.com8926b162012-03-23 15:36:36 +00001599 SkImageFilter* filter = paint.getImageFilter();
1600 if (NULL != filter) {
senorblanco@chromium.org9c397442012-09-27 21:57:45 +00001601 GrTexture* filteredTexture = filter_texture(this, fContext, texture, filter,
robertphillips@google.com8637a362012-04-10 18:32:35 +00001602 GrRect::MakeWH(SkIntToScalar(w), SkIntToScalar(h)));
reed@google.com8926b162012-03-23 15:36:36 +00001603 if (filteredTexture) {
tomhudson@google.com1e8f0162012-07-20 16:25:18 +00001604 grPaint.textureSampler(kBitmapTextureIdx)->setCustomStage(SkNEW_ARGS
1605 (GrSingleTextureEffect, (filteredTexture)))->unref();
reed@google.com8926b162012-03-23 15:36:36 +00001606 texture = filteredTexture;
1607 filteredTexture->unref();
1608 }
reed@google.com76dd2772012-01-05 21:15:07 +00001609 }
rmistry@google.comd6176b02012-08-23 18:14:13 +00001610
bsalomon@google.com5782d712011-01-21 21:03:59 +00001611 fContext->drawRectToRect(grPaint,
reed@google.com76dd2772012-01-05 21:15:07 +00001612 GrRect::MakeXYWH(GrIntToScalar(left),
1613 GrIntToScalar(top),
1614 GrIntToScalar(w),
1615 GrIntToScalar(h)),
1616 GrRect::MakeWH(GR_Scalar1 * w / texture->width(),
1617 GR_Scalar1 * h / texture->height()));
reed@google.comac10a2d2010-12-22 21:39:39 +00001618}
1619
reed@google.com33535f32012-09-25 15:37:50 +00001620void SkGpuDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
1621 const SkRect* src, const SkRect& dst,
1622 const SkPaint& paint) {
robertphillips@google.combac6b052012-09-28 18:06:49 +00001623 SkMatrix matrix;
1624 SkRect bitmapBounds, tmpSrc;
1625
1626 bitmapBounds.set(0, 0,
1627 SkIntToScalar(bitmap.width()),
1628 SkIntToScalar(bitmap.height()));
1629
reed@google.com33535f32012-09-25 15:37:50 +00001630 // Compute matrix from the two rectangles
robertphillips@google.combac6b052012-09-28 18:06:49 +00001631 if (NULL != src) {
1632 tmpSrc = *src;
1633 } else {
1634 tmpSrc = bitmapBounds;
1635 }
1636 matrix.setRectToRect(tmpSrc, dst, SkMatrix::kFill_ScaleToFit);
1637
1638 // clip the tmpSrc to the bounds of the bitmap. No check needed if src==null.
1639 if (NULL != src) {
1640 if (!bitmapBounds.contains(tmpSrc)) {
1641 if (!tmpSrc.intersect(bitmapBounds)) {
1642 return; // nothing to draw
reed@google.com33535f32012-09-25 15:37:50 +00001643 }
reed@google.com33535f32012-09-25 15:37:50 +00001644 }
reed@google.com33535f32012-09-25 15:37:50 +00001645 }
skia.committer@gmail.com7064e9a2012-09-26 02:01:18 +00001646
robertphillips@google.combac6b052012-09-28 18:06:49 +00001647 this->drawBitmapCommon(draw, bitmap, &tmpSrc, matrix, paint);
reed@google.com33535f32012-09-25 15:37:50 +00001648}
1649
bsalomon@google.com06cd7322012-03-30 18:45:35 +00001650void SkGpuDevice::drawDevice(const SkDraw& draw, SkDevice* device,
reed@google.comac10a2d2010-12-22 21:39:39 +00001651 int x, int y, const SkPaint& paint) {
bsalomon@google.com06cd7322012-03-30 18:45:35 +00001652 // clear of the source device must occur before CHECK_SHOULD_DRAW
1653 SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
1654 if (dev->fNeedClear) {
1655 // TODO: could check here whether we really need to draw at all
1656 dev->clear(0x0);
1657 }
1658
reed@google.comac10a2d2010-12-22 21:39:39 +00001659 CHECK_SHOULD_DRAW(draw);
1660
bsalomon@google.com5782d712011-01-21 21:03:59 +00001661 GrPaint grPaint;
twiz@google.com58071162012-07-18 21:41:50 +00001662 SkAutoCachedTexture colorLutTexture;
bsalomon@google.com1c31f632012-07-26 19:39:06 +00001663 grPaint.textureSampler(kBitmapTextureIdx)->reset();
bsalomon@google.com06cd7322012-03-30 18:45:35 +00001664 if (!dev->bindDeviceAsTexture(&grPaint) ||
twiz@google.com58071162012-07-18 21:41:50 +00001665 !skPaint2GrPaintNoShader(this, paint, true, false, &colorLutTexture, &grPaint)) {
bsalomon@google.com5782d712011-01-21 21:03:59 +00001666 return;
reed@google.comac10a2d2010-12-22 21:39:39 +00001667 }
bsalomon@google.com5782d712011-01-21 21:03:59 +00001668
bsalomon@google.com1c31f632012-07-26 19:39:06 +00001669 GrTexture* devTex = grPaint.getTextureSampler(kBitmapTextureIdx).getCustomStage()->texture(0);
bsalomon@google.comb5b31682011-06-16 18:05:35 +00001670 SkASSERT(NULL != devTex);
bsalomon@google.com5782d712011-01-21 21:03:59 +00001671
reed@google.com8926b162012-03-23 15:36:36 +00001672 SkImageFilter* filter = paint.getImageFilter();
1673 if (NULL != filter) {
bsalomon@google.com1c31f632012-07-26 19:39:06 +00001674 GrRect rect = GrRect::MakeWH(SkIntToScalar(devTex->width()),
robertphillips@google.com8637a362012-04-10 18:32:35 +00001675 SkIntToScalar(devTex->height()));
senorblanco@chromium.org9c397442012-09-27 21:57:45 +00001676 GrTexture* filteredTexture = filter_texture(this, fContext, devTex, filter, rect);
reed@google.com8926b162012-03-23 15:36:36 +00001677 if (filteredTexture) {
tomhudson@google.com1e8f0162012-07-20 16:25:18 +00001678 grPaint.textureSampler(kBitmapTextureIdx)->setCustomStage(SkNEW_ARGS
1679 (GrSingleTextureEffect, (filteredTexture)))->unref();
reed@google.com8926b162012-03-23 15:36:36 +00001680 devTex = filteredTexture;
1681 filteredTexture->unref();
1682 }
1683 }
rmistry@google.comd6176b02012-08-23 18:14:13 +00001684
bsalomon@google.com5782d712011-01-21 21:03:59 +00001685 const SkBitmap& bm = dev->accessBitmap(false);
1686 int w = bm.width();
1687 int h = bm.height();
1688
robertphillips@google.comfea85ac2012-07-11 18:53:23 +00001689 GrContext::AutoMatrix avm(fContext, GrMatrix::I());
bsalomon@google.comb5b31682011-06-16 18:05:35 +00001690 GrRect dstRect = GrRect::MakeXYWH(GrIntToScalar(x),
1691 GrIntToScalar(y),
1692 GrIntToScalar(w),
1693 GrIntToScalar(h));
reed@google.com76dd2772012-01-05 21:15:07 +00001694
bsalomon@google.comb5b31682011-06-16 18:05:35 +00001695 // The device being drawn may not fill up its texture (saveLayer uses
1696 // the approximate ).
1697 GrRect srcRect = GrRect::MakeWH(GR_Scalar1 * w / devTex->width(),
1698 GR_Scalar1 * h / devTex->height());
1699
1700 fContext->drawRectToRect(grPaint, dstRect, srcRect);
reed@google.comac10a2d2010-12-22 21:39:39 +00001701}
1702
reed@google.com8926b162012-03-23 15:36:36 +00001703bool SkGpuDevice::canHandleImageFilter(SkImageFilter* filter) {
tomhudson@google.comd0c1a062012-07-12 17:23:52 +00001704 if (!filter->asNewCustomStage(NULL, NULL) &&
senorblanco@chromium.org302cffb2012-08-01 20:16:34 +00001705 !filter->canFilterImageGPU()) {
reed@google.com76dd2772012-01-05 21:15:07 +00001706 return false;
1707 }
reed@google.com8926b162012-03-23 15:36:36 +00001708 return true;
1709}
1710
1711bool SkGpuDevice::filterImage(SkImageFilter* filter, const SkBitmap& src,
1712 const SkMatrix& ctm,
1713 SkBitmap* result, SkIPoint* offset) {
1714 // want explicitly our impl, so guard against a subclass of us overriding it
1715 if (!this->SkGpuDevice::canHandleImageFilter(filter)) {
reed@google.com76dd2772012-01-05 21:15:07 +00001716 return false;
1717 }
reed@google.com8926b162012-03-23 15:36:36 +00001718
1719 SkAutoLockPixels alp(src, !src.getTexture());
1720 if (!src.getTexture() && !src.readyToDraw()) {
1721 return false;
1722 }
1723
1724 GrPaint paint;
1725 paint.reset();
1726
reed@google.com8926b162012-03-23 15:36:36 +00001727 GrTexture* texture;
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001728 // We assume here that the filter will not attempt to tile the src. Otherwise, this cache lookup
1729 // must be pushed upstack.
1730 SkAutoCachedTexture act(this, src, NULL, &texture);
reed@google.com8926b162012-03-23 15:36:36 +00001731
1732 result->setConfig(src.config(), src.width(), src.height());
rmistry@google.comd6176b02012-08-23 18:14:13 +00001733 GrRect rect = GrRect::MakeWH(SkIntToScalar(src.width()),
robertphillips@google.com8637a362012-04-10 18:32:35 +00001734 SkIntToScalar(src.height()));
senorblanco@chromium.org9c397442012-09-27 21:57:45 +00001735 GrTexture* resultTexture = filter_texture(this, fContext, texture, filter, rect);
reed@google.com8926b162012-03-23 15:36:36 +00001736 if (resultTexture) {
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001737 result->setPixelRef(SkNEW_ARGS(SkGrTexturePixelRef,
1738 (resultTexture)))->unref();
reed@google.com8926b162012-03-23 15:36:36 +00001739 resultTexture->unref();
1740 }
reed@google.com76dd2772012-01-05 21:15:07 +00001741 return true;
1742}
1743
reed@google.comac10a2d2010-12-22 21:39:39 +00001744///////////////////////////////////////////////////////////////////////////////
1745
1746// must be in SkCanvas::VertexMode order
bsalomon@google.comffca4002011-02-22 20:34:01 +00001747static const GrPrimitiveType gVertexMode2PrimitiveType[] = {
bsalomon@google.com47059542012-06-06 20:51:20 +00001748 kTriangles_GrPrimitiveType,
1749 kTriangleStrip_GrPrimitiveType,
1750 kTriangleFan_GrPrimitiveType,
reed@google.comac10a2d2010-12-22 21:39:39 +00001751};
1752
1753void SkGpuDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
1754 int vertexCount, const SkPoint vertices[],
1755 const SkPoint texs[], const SkColor colors[],
1756 SkXfermode* xmode,
1757 const uint16_t indices[], int indexCount,
1758 const SkPaint& paint) {
1759 CHECK_SHOULD_DRAW(draw);
1760
bsalomon@google.com5782d712011-01-21 21:03:59 +00001761 GrPaint grPaint;
twiz@google.com58071162012-07-18 21:41:50 +00001762 SkAutoCachedTexture textures[GrPaint::kMaxTextures];
bsalomon@google.com5782d712011-01-21 21:03:59 +00001763 // we ignore the shader if texs is null.
1764 if (NULL == texs) {
twiz@google.com58071162012-07-18 21:41:50 +00001765 if (!skPaint2GrPaintNoShader(this,
1766 paint,
bsalomon@google.com84405e02012-03-05 19:57:21 +00001767 false,
1768 NULL == colors,
twiz@google.com58071162012-07-18 21:41:50 +00001769 &textures[kColorFilterTextureIdx],
bsalomon@google.com84405e02012-03-05 19:57:21 +00001770 &grPaint)) {
reed@google.comac10a2d2010-12-22 21:39:39 +00001771 return;
1772 }
reed@google.comac10a2d2010-12-22 21:39:39 +00001773 } else {
bsalomon@google.com84405e02012-03-05 19:57:21 +00001774 if (!skPaint2GrPaintShader(this,
1775 paint,
bsalomon@google.com84405e02012-03-05 19:57:21 +00001776 NULL == colors,
twiz@google.com58071162012-07-18 21:41:50 +00001777 textures,
bsalomon@google.com84405e02012-03-05 19:57:21 +00001778 &grPaint)) {
bsalomon@google.com5782d712011-01-21 21:03:59 +00001779 return;
1780 }
reed@google.comac10a2d2010-12-22 21:39:39 +00001781 }
bsalomon@google.com5782d712011-01-21 21:03:59 +00001782
1783 if (NULL != xmode && NULL != texs && NULL != colors) {
mike@reedtribe.orgbe2aa2a2011-11-17 02:32:04 +00001784 if (!SkXfermode::IsMode(xmode, SkXfermode::kMultiply_Mode)) {
bsalomon@google.com5782d712011-01-21 21:03:59 +00001785 SkDebugf("Unsupported vertex-color/texture xfer mode.\n");
1786#if 0
1787 return
1788#endif
1789 }
reed@google.comac10a2d2010-12-22 21:39:39 +00001790 }
bsalomon@google.com5782d712011-01-21 21:03:59 +00001791
bsalomon@google.com498776a2011-08-16 19:20:44 +00001792 SkAutoSTMalloc<128, GrColor> convertedColors(0);
1793 if (NULL != colors) {
1794 // need to convert byte order and from non-PM to PM
bsalomon@google.com7d4679a2011-09-02 22:06:24 +00001795 convertedColors.reset(vertexCount);
bsalomon@google.com498776a2011-08-16 19:20:44 +00001796 for (int i = 0; i < vertexCount; ++i) {
rileya@google.com24f3ad12012-07-18 21:47:40 +00001797 convertedColors[i] = SkColor2GrColor(colors[i]);
bsalomon@google.com498776a2011-08-16 19:20:44 +00001798 }
1799 colors = convertedColors.get();
reed@google.comac10a2d2010-12-22 21:39:39 +00001800 }
bsalomon@google.com498776a2011-08-16 19:20:44 +00001801 fContext->drawVertices(grPaint,
1802 gVertexMode2PrimitiveType[vmode],
1803 vertexCount,
1804 (GrPoint*) vertices,
1805 (GrPoint*) texs,
1806 colors,
1807 indices,
1808 indexCount);
reed@google.comac10a2d2010-12-22 21:39:39 +00001809}
1810
1811///////////////////////////////////////////////////////////////////////////////
1812
1813static void GlyphCacheAuxProc(void* data) {
reed@google.com26344cf2012-06-27 18:23:01 +00001814 GrFontScaler* scaler = (GrFontScaler*)data;
1815 SkSafeUnref(scaler);
reed@google.comac10a2d2010-12-22 21:39:39 +00001816}
1817
1818static GrFontScaler* get_gr_font_scaler(SkGlyphCache* cache) {
1819 void* auxData;
1820 GrFontScaler* scaler = NULL;
1821 if (cache->getAuxProcData(GlyphCacheAuxProc, &auxData)) {
1822 scaler = (GrFontScaler*)auxData;
1823 }
1824 if (NULL == scaler) {
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001825 scaler = SkNEW_ARGS(SkGrFontScaler, (cache));
reed@google.comac10a2d2010-12-22 21:39:39 +00001826 cache->setAuxProc(GlyphCacheAuxProc, scaler);
1827 }
1828 return scaler;
1829}
1830
1831static void SkGPU_Draw1Glyph(const SkDraw1Glyph& state,
1832 SkFixed fx, SkFixed fy,
1833 const SkGlyph& glyph) {
1834 SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
1835
bungeman@google.com15865a72012-01-11 16:28:04 +00001836 GrSkDrawProcs* procs = static_cast<GrSkDrawProcs*>(state.fDraw->fProcs);
reed@google.comac10a2d2010-12-22 21:39:39 +00001837
1838 if (NULL == procs->fFontScaler) {
1839 procs->fFontScaler = get_gr_font_scaler(state.fCache);
1840 }
reed@google.com39ce0ac2011-04-08 15:42:19 +00001841
bungeman@google.com15865a72012-01-11 16:28:04 +00001842 procs->fTextContext->drawPackedGlyph(GrGlyph::Pack(glyph.getGlyphID(),
1843 glyph.getSubXFixed(),
1844 glyph.getSubYFixed()),
1845 SkFixedFloorToFixed(fx),
1846 SkFixedFloorToFixed(fy),
reed@google.comac10a2d2010-12-22 21:39:39 +00001847 procs->fFontScaler);
1848}
1849
bsalomon@google.com5782d712011-01-21 21:03:59 +00001850SkDrawProcs* SkGpuDevice::initDrawForText(GrTextContext* context) {
reed@google.comac10a2d2010-12-22 21:39:39 +00001851
1852 // deferred allocation
1853 if (NULL == fDrawProcs) {
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001854 fDrawProcs = SkNEW(GrSkDrawProcs);
reed@google.comac10a2d2010-12-22 21:39:39 +00001855 fDrawProcs->fD1GProc = SkGPU_Draw1Glyph;
1856 fDrawProcs->fContext = fContext;
1857 }
1858
1859 // init our (and GL's) state
1860 fDrawProcs->fTextContext = context;
1861 fDrawProcs->fFontScaler = NULL;
1862 return fDrawProcs;
1863}
1864
1865void SkGpuDevice::drawText(const SkDraw& draw, const void* text,
1866 size_t byteLength, SkScalar x, SkScalar y,
1867 const SkPaint& paint) {
1868 CHECK_SHOULD_DRAW(draw);
1869
tomhudson@google.comdd5f7442011-08-30 15:13:55 +00001870 if (draw.fMatrix->hasPerspective()) {
reed@google.comac10a2d2010-12-22 21:39:39 +00001871 // this guy will just call our drawPath()
1872 draw.drawText((const char*)text, byteLength, x, y, paint);
1873 } else {
reed@google.comac10a2d2010-12-22 21:39:39 +00001874 SkDraw myDraw(draw);
bsalomon@google.com5782d712011-01-21 21:03:59 +00001875
1876 GrPaint grPaint;
twiz@google.com58071162012-07-18 21:41:50 +00001877 SkAutoCachedTexture textures[GrPaint::kMaxTextures];
bsalomon@google.com84405e02012-03-05 19:57:21 +00001878 if (!skPaint2GrPaintShader(this,
1879 paint,
bsalomon@google.com84405e02012-03-05 19:57:21 +00001880 true,
twiz@google.com58071162012-07-18 21:41:50 +00001881 textures,
bsalomon@google.com84405e02012-03-05 19:57:21 +00001882 &grPaint)) {
bsalomon@google.com5782d712011-01-21 21:03:59 +00001883 return;
1884 }
tomhudson@google.com375ff852012-06-29 18:37:57 +00001885 GrTextContext context(fContext, grPaint, draw.fExtMatrix);
1886 myDraw.fProcs = this->initDrawForText(&context);
reed@google.comac10a2d2010-12-22 21:39:39 +00001887 this->INHERITED::drawText(myDraw, text, byteLength, x, y, paint);
1888 }
1889}
1890
1891void SkGpuDevice::drawPosText(const SkDraw& draw, const void* text,
1892 size_t byteLength, const SkScalar pos[],
1893 SkScalar constY, int scalarsPerPos,
1894 const SkPaint& paint) {
1895 CHECK_SHOULD_DRAW(draw);
1896
tomhudson@google.comdd5f7442011-08-30 15:13:55 +00001897 if (draw.fMatrix->hasPerspective()) {
reed@google.comac10a2d2010-12-22 21:39:39 +00001898 // this guy will just call our drawPath()
1899 draw.drawPosText((const char*)text, byteLength, pos, constY,
1900 scalarsPerPos, paint);
1901 } else {
reed@google.comac10a2d2010-12-22 21:39:39 +00001902 SkDraw myDraw(draw);
bsalomon@google.com5782d712011-01-21 21:03:59 +00001903
1904 GrPaint grPaint;
twiz@google.com58071162012-07-18 21:41:50 +00001905 SkAutoCachedTexture textures[GrPaint::kMaxTextures];
bsalomon@google.com84405e02012-03-05 19:57:21 +00001906 if (!skPaint2GrPaintShader(this,
1907 paint,
bsalomon@google.com84405e02012-03-05 19:57:21 +00001908 true,
twiz@google.com58071162012-07-18 21:41:50 +00001909 textures,
bsalomon@google.com84405e02012-03-05 19:57:21 +00001910 &grPaint)) {
bsalomon@google.com5782d712011-01-21 21:03:59 +00001911 return;
1912 }
tomhudson@google.com375ff852012-06-29 18:37:57 +00001913 GrTextContext context(fContext, grPaint, draw.fExtMatrix);
1914 myDraw.fProcs = this->initDrawForText(&context);
reed@google.comac10a2d2010-12-22 21:39:39 +00001915 this->INHERITED::drawPosText(myDraw, text, byteLength, pos, constY,
1916 scalarsPerPos, paint);
1917 }
1918}
1919
1920void SkGpuDevice::drawTextOnPath(const SkDraw& draw, const void* text,
1921 size_t len, const SkPath& path,
1922 const SkMatrix* m, const SkPaint& paint) {
1923 CHECK_SHOULD_DRAW(draw);
1924
1925 SkASSERT(draw.fDevice == this);
1926 draw.drawTextOnPath((const char*)text, len, path, m, paint);
1927}
1928
1929///////////////////////////////////////////////////////////////////////////////
1930
reed@google.comf67e4cf2011-03-15 20:56:58 +00001931bool SkGpuDevice::filterTextFlags(const SkPaint& paint, TextFlags* flags) {
1932 if (!paint.isLCDRenderText()) {
1933 // we're cool with the paint as is
1934 return false;
1935 }
1936
1937 if (paint.getShader() ||
1938 paint.getXfermode() || // unless its srcover
1939 paint.getMaskFilter() ||
1940 paint.getRasterizer() ||
1941 paint.getColorFilter() ||
1942 paint.getPathEffect() ||
1943 paint.isFakeBoldText() ||
1944 paint.getStyle() != SkPaint::kFill_Style) {
1945 // turn off lcd
1946 flags->fFlags = paint.getFlags() & ~SkPaint::kLCDRenderText_Flag;
1947 flags->fHinting = paint.getHinting();
1948 return true;
1949 }
1950 // we're cool with the paint as is
1951 return false;
1952}
1953
reed@google.com75d939b2011-12-07 15:07:23 +00001954void SkGpuDevice::flush() {
bsalomon@google.com06cd7322012-03-30 18:45:35 +00001955 DO_DEFERRED_CLEAR;
bsalomon@google.com75f9f252012-01-31 13:35:56 +00001956 fContext->resolveRenderTarget(fRenderTarget);
reed@google.com75d939b2011-12-07 15:07:23 +00001957}
1958
reed@google.comf67e4cf2011-03-15 20:56:58 +00001959///////////////////////////////////////////////////////////////////////////////
1960
bsalomon@google.comfb309512011-11-30 14:13:48 +00001961bool SkGpuDevice::isBitmapInTextureCache(const SkBitmap& bitmap,
bsalomon@google.comb8670992012-07-25 21:27:09 +00001962 const GrTextureParams& params) const {
robertphillips@google.com75b3c962012-06-07 12:08:45 +00001963 uint64_t key = bitmap.getGenerationID();
bsalomon@google.comfb309512011-11-30 14:13:48 +00001964 key |= ((uint64_t) bitmap.pixelRefOffset()) << 32;
bsalomon@google.comfb309512011-11-30 14:13:48 +00001965
robertphillips@google.com75b3c962012-06-07 12:08:45 +00001966 GrTextureDesc desc;
1967 desc.fWidth = bitmap.width();
1968 desc.fHeight = bitmap.height();
rileya@google.com24f3ad12012-07-18 21:47:40 +00001969 desc.fConfig = SkBitmapConfig2GrPixelConfig(bitmap.config());
robertphillips@google.coma1e57952012-06-04 20:05:28 +00001970
robertphillips@google.com9c2ea842012-08-13 17:47:59 +00001971 GrCacheData cacheData(key);
1972
1973 return this->context()->isTextureInCache(desc, cacheData, &params);
bsalomon@google.comfb309512011-11-30 14:13:48 +00001974}
1975
1976
vandebo@chromium.org74b46192012-01-28 01:45:11 +00001977SkDevice* SkGpuDevice::onCreateCompatibleDevice(SkBitmap::Config config,
1978 int width, int height,
bsalomon@google.come97f0852011-06-17 13:10:25 +00001979 bool isOpaque,
1980 Usage usage) {
bsalomon@google.com06cd7322012-03-30 18:45:35 +00001981 GrTextureDesc desc;
1982 desc.fConfig = fRenderTarget->config();
1983 desc.fFlags = kRenderTarget_GrTextureFlagBit;
1984 desc.fWidth = width;
1985 desc.fHeight = height;
1986 desc.fSampleCnt = fRenderTarget->numSamples();
1987
bsalomon@google.com06cd7322012-03-30 18:45:35 +00001988 GrTexture* texture;
1989 SkAutoTUnref<GrTexture> tunref;
bsalomon@google.com1b3ac8b2012-04-09 21:40:54 +00001990 // Skia's convention is to only clear a device if it is non-opaque.
1991 bool needClear = !isOpaque;
bsalomon@google.com06cd7322012-03-30 18:45:35 +00001992
1993#if CACHE_COMPATIBLE_DEVICE_TEXTURES
1994 // layers are never draw in repeat modes, so we can request an approx
1995 // match and ignore any padding.
1996 GrContext::ScratchTexMatch matchType = (kSaveLayer_Usage == usage) ?
1997 GrContext::kApprox_ScratchTexMatch :
1998 GrContext::kExact_ScratchTexMatch;
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +00001999 texture = fContext->lockScratchTexture(desc, matchType);
bsalomon@google.com06cd7322012-03-30 18:45:35 +00002000#else
2001 tunref.reset(fContext->createUncachedTexture(desc, NULL, 0));
2002 texture = tunref.get();
2003#endif
2004 if (texture) {
2005 return SkNEW_ARGS(SkGpuDevice,(fContext,
2006 texture,
bsalomon@google.com06cd7322012-03-30 18:45:35 +00002007 needClear));
2008 } else {
2009 GrPrintf("---- failed to create compatible device texture [%d %d]\n",
2010 width, height);
2011 return NULL;
2012 }
2013}
2014
2015SkGpuDevice::SkGpuDevice(GrContext* context,
2016 GrTexture* texture,
bsalomon@google.com06cd7322012-03-30 18:45:35 +00002017 bool needClear)
robertphillips@google.com641f8b12012-07-31 19:15:58 +00002018 : SkDevice(make_bitmap(context, texture->asRenderTarget())) {
2019
bsalomon@google.com06cd7322012-03-30 18:45:35 +00002020 GrAssert(texture && texture->asRenderTarget());
bsalomon@google.com8090e652012-08-28 15:07:11 +00002021 // This constructor is called from onCreateCompatibleDevice. It has locked the RT in the texture
2022 // cache. We pass true for the third argument so that it will get unlocked.
2023 this->initFromRenderTarget(context, texture->asRenderTarget(), true);
bsalomon@google.com06cd7322012-03-30 18:45:35 +00002024 fNeedClear = needClear;
bsalomon@google.come97f0852011-06-17 13:10:25 +00002025}