blob: 7e0c915fc94a662fafb2fb1d5b8747bc377bbe60 [file] [log] [blame]
epoger@google.comec3ed6a2011-07-28 14:26:00 +00001
bsalomon@google.com27847de2011-02-22 20:59:41 +00002/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00003 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
bsalomon@google.com27847de2011-02-22 20:59:41 +00007 */
8
epoger@google.comec3ed6a2011-07-28 14:26:00 +00009
bsalomon@google.com1fadb202011-12-12 16:10:08 +000010#include "GrContext.h"
11
bsalomon@google.comb505a122012-05-31 18:40:36 +000012#include "effects/GrConvolutionEffect.h"
tomhudson@google.comaa72eab2012-07-19 18:01:07 +000013#include "effects/GrSingleTextureEffect.h"
bsalomon@google.coma04e8e82012-08-27 12:53:13 +000014#include "effects/GrConfigConversionEffect.h"
bsalomon@google.comb505a122012-05-31 18:40:36 +000015
tomhudson@google.com278cbb42011-06-30 19:37:01 +000016#include "GrBufferAllocPool.h"
bsalomon@google.com05ef5102011-05-02 21:14:59 +000017#include "GrGpu.h"
bsalomon@google.com27847de2011-02-22 20:59:41 +000018#include "GrIndexBuffer.h"
19#include "GrInOrderDrawBuffer.h"
bsalomon@google.com27847de2011-02-22 20:59:41 +000020#include "GrPathRenderer.h"
tomhudson@google.comd22b6e42011-06-24 15:53:40 +000021#include "GrPathUtils.h"
bsalomon@google.com50398bf2011-07-26 20:45:30 +000022#include "GrResourceCache.h"
robertphillips@google.com72176b22012-05-23 13:19:12 +000023#include "GrSoftwarePathRenderer.h"
bsalomon@google.com558a75b2011-08-08 17:01:14 +000024#include "GrStencilBuffer.h"
tomhudson@google.com278cbb42011-06-30 19:37:01 +000025#include "GrTextStrike.h"
bsalomon@google.com8c2fe992011-09-13 15:27:18 +000026#include "SkTLazy.h"
bsalomon@google.comc0af3172012-06-15 14:10:09 +000027#include "SkTLS.h"
tomhudson@google.com0c8d93a2011-07-01 17:08:26 +000028#include "SkTrace.h"
bsalomon@google.com27847de2011-02-22 20:59:41 +000029
reed@google.comfa35e3d2012-06-26 20:16:17 +000030SK_DEFINE_INST_COUNT(GrContext)
31SK_DEFINE_INST_COUNT(GrDrawState)
32
bsalomon@google.com1d4edd32012-08-16 18:36:06 +000033// It can be useful to set this to kNo_BufferedDraw to test whether a bug is caused by using the
34// InOrderDrawBuffer, to compare performance of using/not using InOrderDrawBuffer, or to make
35// debugging easier.
36#define DEFAULT_BUFFERING (GR_DISABLE_DRAW_BUFFERING ? kNo_BufferedDraw : kYes_BufferedDraw)
bsalomon@google.com27847de2011-02-22 20:59:41 +000037
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +000038#define MAX_BLUR_SIGMA 4.0f
39
bsalomon@google.comd46e2422011-09-23 17:40:07 +000040// When we're using coverage AA but the blend is incompatible (given gpu
41// limitations) should we disable AA or draw wrong?
bsalomon@google.com950d7a82011-09-28 15:05:33 +000042#define DISABLE_COVERAGE_AA_FOR_BLEND 1
bsalomon@google.comd46e2422011-09-23 17:40:07 +000043
reed@google.com4b2d3f32012-05-15 18:05:50 +000044#if GR_DEBUG
45 // change this to a 1 to see notifications when partial coverage fails
46 #define GR_DEBUG_PARTIAL_COVERAGE_CHECK 0
47#else
48 #define GR_DEBUG_PARTIAL_COVERAGE_CHECK 0
49#endif
50
bsalomon@google.com07fc0d12012-06-22 15:15:59 +000051static const size_t MAX_TEXTURE_CACHE_COUNT = 256;
52static const size_t MAX_TEXTURE_CACHE_BYTES = 16 * 1024 * 1024;
bsalomon@google.com27847de2011-02-22 20:59:41 +000053
bsalomon@google.com60361492012-03-15 17:47:06 +000054static const size_t DRAW_BUFFER_VBPOOL_BUFFER_SIZE = 1 << 15;
bsalomon@google.com27847de2011-02-22 20:59:41 +000055static const int DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS = 4;
56
bsalomon@google.com1d4edd32012-08-16 18:36:06 +000057static const size_t DRAW_BUFFER_IBPOOL_BUFFER_SIZE = 1 << 11;
58static const int DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS = 4;
bsalomon@google.com27847de2011-02-22 20:59:41 +000059
bsalomon@google.combc4b6542011-11-19 13:56:11 +000060#define ASSERT_OWNED_RESOURCE(R) GrAssert(!(R) || (R)->getContext() == this)
61
bsalomon@google.com05ef5102011-05-02 21:14:59 +000062GrContext* GrContext::Create(GrEngine engine,
63 GrPlatform3DContext context3D) {
bsalomon@google.com27847de2011-02-22 20:59:41 +000064 GrContext* ctx = NULL;
65 GrGpu* fGpu = GrGpu::Create(engine, context3D);
66 if (NULL != fGpu) {
tomhudson@google.comc377baf2012-07-09 20:17:56 +000067 ctx = SkNEW_ARGS(GrContext, (fGpu));
bsalomon@google.com27847de2011-02-22 20:59:41 +000068 fGpu->unref();
69 }
70 return ctx;
71}
72
bsalomon@google.comc0af3172012-06-15 14:10:09 +000073namespace {
74void* CreateThreadInstanceCount() {
tomhudson@google.comc377baf2012-07-09 20:17:56 +000075 return SkNEW_ARGS(int, (0));
bsalomon@google.comc0af3172012-06-15 14:10:09 +000076}
77void DeleteThreadInstanceCount(void* v) {
78 delete reinterpret_cast<int*>(v);
79}
80#define THREAD_INSTANCE_COUNT \
81 (*reinterpret_cast<int*>(SkTLS::Get(CreateThreadInstanceCount, \
82 DeleteThreadInstanceCount)))
83
84}
85
86int GrContext::GetThreadInstanceCount() {
87 return THREAD_INSTANCE_COUNT;
88}
89
bsalomon@google.com27847de2011-02-22 20:59:41 +000090GrContext::~GrContext() {
robertphillips@google.comcdb426d2012-09-24 19:33:59 +000091 for (int i = 0; i < fCleanUpData.count(); ++i) {
92 (*fCleanUpData[i].fFunc)(this, fCleanUpData[i].fInfo);
93 }
94
bsalomon@google.com8fe72472011-03-30 21:26:44 +000095 this->flush();
robertphillips@google.com5acc0e32012-05-17 12:01:02 +000096
97 // Since the gpu can hold scratch textures, give it a chance to let go
98 // of them before freeing the texture cache
99 fGpu->purgeResources();
100
bsalomon@google.com27847de2011-02-22 20:59:41 +0000101 delete fTextureCache;
robertphillips@google.comeb9b3e12012-09-11 12:50:53 +0000102 fTextureCache = NULL;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000103 delete fFontCache;
104 delete fDrawBuffer;
105 delete fDrawBufferVBAllocPool;
bsalomon@google.comde6ac2d2011-02-25 21:50:42 +0000106 delete fDrawBufferIBAllocPool;
bsalomon@google.com30085192011-08-19 15:42:31 +0000107
robertphillips@google.comf6747b02012-06-12 00:32:28 +0000108 fAARectRenderer->unref();
109
bsalomon@google.com205d4602011-04-25 12:43:45 +0000110 fGpu->unref();
bsalomon@google.com30085192011-08-19 15:42:31 +0000111 GrSafeUnref(fPathRendererChain);
robertphillips@google.com72176b22012-05-23 13:19:12 +0000112 GrSafeUnref(fSoftwarePathRenderer);
bsalomon@google.com10e04bf2012-03-30 14:35:04 +0000113 fDrawState->unref();
bsalomon@google.comc0af3172012-06-15 14:10:09 +0000114
115 --THREAD_INSTANCE_COUNT;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000116}
117
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000118void GrContext::contextLost() {
junov@google.com53a55842011-06-08 22:55:10 +0000119 contextDestroyed();
120 this->setupDrawBuffer();
121}
122
123void GrContext::contextDestroyed() {
bsalomon@google.com205d4602011-04-25 12:43:45 +0000124 // abandon first to so destructors
125 // don't try to free the resources in the API.
126 fGpu->abandonResources();
127
bsalomon@google.com30085192011-08-19 15:42:31 +0000128 // a path renderer may be holding onto resources that
129 // are now unusable
130 GrSafeSetNull(fPathRendererChain);
robertphillips@google.com72176b22012-05-23 13:19:12 +0000131 GrSafeSetNull(fSoftwarePathRenderer);
bsalomon@google.com30085192011-08-19 15:42:31 +0000132
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000133 delete fDrawBuffer;
134 fDrawBuffer = NULL;
bsalomon@google.com205d4602011-04-25 12:43:45 +0000135
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000136 delete fDrawBufferVBAllocPool;
137 fDrawBufferVBAllocPool = NULL;
bsalomon@google.com205d4602011-04-25 12:43:45 +0000138
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000139 delete fDrawBufferIBAllocPool;
140 fDrawBufferIBAllocPool = NULL;
141
robertphillips@google.comf6747b02012-06-12 00:32:28 +0000142 fAARectRenderer->reset();
bsalomon@google.com205d4602011-04-25 12:43:45 +0000143
bsalomon@google.coma2921122012-08-28 12:34:17 +0000144 fTextureCache->purgeAllUnlocked();
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000145 fFontCache->freeAll();
146 fGpu->markContextDirty();
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000147}
148
149void GrContext::resetContext() {
150 fGpu->markContextDirty();
151}
152
153void GrContext::freeGpuResources() {
154 this->flush();
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000155
robertphillips@google.comff175842012-05-14 19:31:39 +0000156 fGpu->purgeResources();
157
robertphillips@google.comf6747b02012-06-12 00:32:28 +0000158 fAARectRenderer->reset();
159
bsalomon@google.coma2921122012-08-28 12:34:17 +0000160 fTextureCache->purgeAllUnlocked();
bsalomon@google.com8fe72472011-03-30 21:26:44 +0000161 fFontCache->freeAll();
bsalomon@google.com30085192011-08-19 15:42:31 +0000162 // a path renderer may be holding onto resources
163 GrSafeSetNull(fPathRendererChain);
robertphillips@google.com72176b22012-05-23 13:19:12 +0000164 GrSafeSetNull(fSoftwarePathRenderer);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000165}
166
twiz@google.com05e70242012-01-27 19:12:00 +0000167size_t GrContext::getGpuTextureCacheBytes() const {
168 return fTextureCache->getCachedResourceBytes();
169}
170
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000171////////////////////////////////////////////////////////////////////////////////
172
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000173namespace {
bsalomon@google.com558a75b2011-08-08 17:01:14 +0000174
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +0000175void scale_rect(SkRect* rect, float xScale, float yScale) {
robertphillips@google.com5af56062012-04-27 15:39:52 +0000176 rect->fLeft = SkScalarMul(rect->fLeft, SkFloatToScalar(xScale));
177 rect->fTop = SkScalarMul(rect->fTop, SkFloatToScalar(yScale));
178 rect->fRight = SkScalarMul(rect->fRight, SkFloatToScalar(xScale));
179 rect->fBottom = SkScalarMul(rect->fBottom, SkFloatToScalar(yScale));
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +0000180}
181
bsalomon@google.comb505a122012-05-31 18:40:36 +0000182float adjust_sigma(float sigma, int *scaleFactor, int *radius) {
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +0000183 *scaleFactor = 1;
184 while (sigma > MAX_BLUR_SIGMA) {
185 *scaleFactor *= 2;
186 sigma *= 0.5f;
187 }
bsalomon@google.comb505a122012-05-31 18:40:36 +0000188 *radius = static_cast<int>(ceilf(sigma * 3.0f));
189 GrAssert(*radius <= GrConvolutionEffect::kMaxKernelRadius);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +0000190 return sigma;
191}
192
bsalomon@google.com07ea2db2012-08-17 14:06:49 +0000193void convolve_gaussian(GrDrawTarget* target,
bsalomon@google.comb505a122012-05-31 18:40:36 +0000194 GrTexture* texture,
195 const SkRect& rect,
196 float sigma,
197 int radius,
198 Gr1DKernelEffect::Direction direction) {
bsalomon@google.com07ea2db2012-08-17 14:06:49 +0000199 GrRenderTarget* rt = target->drawState()->getRenderTarget();
200 GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kReset_ASRInit);
201 GrDrawState* drawState = target->drawState();
202 drawState->setRenderTarget(rt);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +0000203 GrMatrix sampleM;
204 sampleM.setIDiv(texture->width(), texture->height());
bsalomon@google.comb505a122012-05-31 18:40:36 +0000205 drawState->sampler(0)->reset(sampleM);
tomhudson@google.comc377baf2012-07-09 20:17:56 +0000206 SkAutoTUnref<GrConvolutionEffect> conv(SkNEW_ARGS(GrConvolutionEffect,
tomhudson@google.comfde2c0a2012-07-16 12:23:32 +0000207 (texture, direction, radius,
208 sigma)));
bsalomon@google.comb505a122012-05-31 18:40:36 +0000209 drawState->sampler(0)->setCustomStage(conv);
bsalomon@google.com07ea2db2012-08-17 14:06:49 +0000210 target->drawSimpleRect(rect, NULL);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +0000211}
212
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000213}
214
robertphillips@google.coma9b06232012-08-30 11:06:31 +0000215
216GrTexture* GrContext::findTexture(const GrCacheKey& key) {
217 return static_cast<GrTexture*>(fTextureCache->find(key.key()));
218}
219
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000220GrTexture* GrContext::findTexture(const GrTextureDesc& desc,
221 const GrCacheData& cacheData,
222 const GrTextureParams* params) {
robertphillips@google.com9c2ea842012-08-13 17:47:59 +0000223 GrResourceKey resourceKey = GrTexture::ComputeKey(fGpu, params, desc, cacheData, false);
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000224 GrResource* resource = fTextureCache->find(resourceKey);
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000225 return static_cast<GrTexture*>(resource);
bsalomon@google.com558a75b2011-08-08 17:01:14 +0000226}
227
robertphillips@google.com75b3c962012-06-07 12:08:45 +0000228bool GrContext::isTextureInCache(const GrTextureDesc& desc,
robertphillips@google.com9c2ea842012-08-13 17:47:59 +0000229 const GrCacheData& cacheData,
bsalomon@google.comb8670992012-07-25 21:27:09 +0000230 const GrTextureParams* params) const {
robertphillips@google.com9c2ea842012-08-13 17:47:59 +0000231 GrResourceKey resourceKey = GrTexture::ComputeKey(fGpu, params, desc, cacheData, false);
bsalomon@google.comfb309512011-11-30 14:13:48 +0000232 return fTextureCache->hasKey(resourceKey);
233}
234
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000235void GrContext::addStencilBuffer(GrStencilBuffer* sb) {
bsalomon@google.combc4b6542011-11-19 13:56:11 +0000236 ASSERT_OWNED_RESOURCE(sb);
robertphillips@google.com46a86002012-08-08 10:42:44 +0000237
238 GrResourceKey resourceKey = GrStencilBuffer::ComputeKey(sb->width(),
239 sb->height(),
240 sb->numSamples());
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000241 fTextureCache->create(resourceKey, sb);
bsalomon@google.com558a75b2011-08-08 17:01:14 +0000242}
243
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000244GrStencilBuffer* GrContext::findStencilBuffer(int width, int height,
bsalomon@google.com558a75b2011-08-08 17:01:14 +0000245 int sampleCnt) {
robertphillips@google.com46a86002012-08-08 10:42:44 +0000246 GrResourceKey resourceKey = GrStencilBuffer::ComputeKey(width,
247 height,
248 sampleCnt);
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000249 GrResource* resource = fTextureCache->find(resourceKey);
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000250 return static_cast<GrStencilBuffer*>(resource);
bsalomon@google.com558a75b2011-08-08 17:01:14 +0000251}
252
bsalomon@google.com27847de2011-02-22 20:59:41 +0000253static void stretchImage(void* dst,
254 int dstW,
255 int dstH,
256 void* src,
257 int srcW,
258 int srcH,
259 int bpp) {
260 GrFixed dx = (srcW << 16) / dstW;
261 GrFixed dy = (srcH << 16) / dstH;
262
263 GrFixed y = dy >> 1;
264
265 int dstXLimit = dstW*bpp;
266 for (int j = 0; j < dstH; ++j) {
267 GrFixed x = dx >> 1;
268 void* srcRow = (uint8_t*)src + (y>>16)*srcW*bpp;
269 void* dstRow = (uint8_t*)dst + j*dstW*bpp;
270 for (int i = 0; i < dstXLimit; i += bpp) {
271 memcpy((uint8_t*) dstRow + i,
272 (uint8_t*) srcRow + (x>>16)*bpp,
273 bpp);
274 x += dx;
275 }
276 y += dy;
277 }
278}
279
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000280// The desired texture is NPOT and tiled but that isn't supported by
robertphillips@google.com3319f332012-08-13 18:00:36 +0000281// the current hardware. Resize the texture to be a POT
282GrTexture* GrContext::createResizedTexture(const GrTextureDesc& desc,
283 const GrCacheData& cacheData,
284 void* srcData,
285 size_t rowBytes,
286 bool needsFiltering) {
robertphillips@google.com0d25eef2012-09-11 21:25:51 +0000287 GrTexture* clampedTexture = this->findTexture(desc, cacheData, NULL);
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000288 if (NULL == clampedTexture) {
robertphillips@google.com0d25eef2012-09-11 21:25:51 +0000289 clampedTexture = this->createTexture(NULL, desc, cacheData, srcData, rowBytes);
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000290
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000291 GrAssert(NULL != clampedTexture);
292 if (NULL == clampedTexture) {
robertphillips@google.com3319f332012-08-13 18:00:36 +0000293 return NULL;
294 }
295 }
robertphillips@google.com0d25eef2012-09-11 21:25:51 +0000296
297 clampedTexture->ref();
298
robertphillips@google.com3319f332012-08-13 18:00:36 +0000299 GrTextureDesc rtDesc = desc;
300 rtDesc.fFlags = rtDesc.fFlags |
301 kRenderTarget_GrTextureFlagBit |
302 kNoStencil_GrTextureFlagBit;
303 rtDesc.fWidth = GrNextPow2(GrMax(desc.fWidth, 64));
304 rtDesc.fHeight = GrNextPow2(GrMax(desc.fHeight, 64));
305
306 GrTexture* texture = fGpu->createTexture(rtDesc, NULL, 0);
307
308 if (NULL != texture) {
309 GrDrawTarget::AutoStateRestore asr(fGpu, GrDrawTarget::kReset_ASRInit);
310 GrDrawState* drawState = fGpu->drawState();
311 drawState->setRenderTarget(texture->asRenderTarget());
312
313 // if filtering is not desired then we want to ensure all
314 // texels in the resampled image are copies of texels from
315 // the original.
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +0000316 drawState->sampler(0)->reset();
317 GrTextureParams params(SkShader::kClamp_TileMode, needsFiltering);
318 drawState->createTextureEffect(0, clampedTexture, params);
robertphillips@google.com3319f332012-08-13 18:00:36 +0000319
320 static const GrVertexLayout layout =
321 GrDrawTarget::StageTexCoordVertexLayoutBit(0,0);
322 GrDrawTarget::AutoReleaseGeometry arg(fGpu, layout, 4, 0);
323
324 if (arg.succeeded()) {
325 GrPoint* verts = (GrPoint*) arg.vertices();
326 verts[0].setIRectFan(0, 0,
327 texture->width(),
328 texture->height(),
329 2*sizeof(GrPoint));
330 verts[1].setIRectFan(0, 0, 1, 1, 2*sizeof(GrPoint));
331 fGpu->drawNonIndexed(kTriangleFan_GrPrimitiveType,
332 0, 4);
333 }
334 texture->releaseRenderTarget();
335 } else {
336 // TODO: Our CPU stretch doesn't filter. But we create separate
337 // stretched textures when the sampler state is either filtered or
338 // not. Either implement filtered stretch blit on CPU or just create
339 // one when FBO case fails.
340
341 rtDesc.fFlags = kNone_GrTextureFlags;
342 // no longer need to clamp at min RT size.
343 rtDesc.fWidth = GrNextPow2(desc.fWidth);
344 rtDesc.fHeight = GrNextPow2(desc.fHeight);
345 int bpp = GrBytesPerPixel(desc.fConfig);
346 SkAutoSMalloc<128*128*4> stretchedPixels(bpp *
347 rtDesc.fWidth *
348 rtDesc.fHeight);
349 stretchImage(stretchedPixels.get(), rtDesc.fWidth, rtDesc.fHeight,
350 srcData, desc.fWidth, desc.fHeight, bpp);
351
352 size_t stretchedRowBytes = rtDesc.fWidth * bpp;
353
354 GrTexture* texture = fGpu->createTexture(rtDesc,
355 stretchedPixels.get(),
356 stretchedRowBytes);
357 GrAssert(NULL != texture);
358 }
robertphillips@google.com3319f332012-08-13 18:00:36 +0000359
robertphillips@google.com0d25eef2012-09-11 21:25:51 +0000360 clampedTexture->unref();
robertphillips@google.com3319f332012-08-13 18:00:36 +0000361 return texture;
362}
363
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000364GrTexture* GrContext::createTexture(
bsalomon@google.comb8670992012-07-25 21:27:09 +0000365 const GrTextureParams* params,
bsalomon@google.com1fadb202011-12-12 16:10:08 +0000366 const GrTextureDesc& desc,
robertphillips@google.com9c2ea842012-08-13 17:47:59 +0000367 const GrCacheData& cacheData,
bsalomon@google.com1fadb202011-12-12 16:10:08 +0000368 void* srcData,
369 size_t rowBytes) {
tomhudson@google.com278cbb42011-06-30 19:37:01 +0000370 SK_TRACE_EVENT0("GrContext::createAndLockTexture");
bsalomon@google.com27847de2011-02-22 20:59:41 +0000371
372#if GR_DUMP_TEXTURE_UPLOAD
373 GrPrintf("GrContext::createAndLockTexture [%d %d]\n", desc.fWidth, desc.fHeight);
374#endif
375
robertphillips@google.com9c2ea842012-08-13 17:47:59 +0000376 GrResourceKey resourceKey = GrTexture::ComputeKey(fGpu, params, desc, cacheData, false);
robertphillips@google.coma1e57952012-06-04 20:05:28 +0000377
robertphillips@google.comf2e93fc2012-09-05 19:44:18 +0000378 SkAutoTUnref<GrTexture> texture;
robertphillips@google.coma1e57952012-06-04 20:05:28 +0000379 if (GrTexture::NeedsResizing(resourceKey)) {
robertphillips@google.comf2e93fc2012-09-05 19:44:18 +0000380 texture.reset(this->createResizedTexture(desc, cacheData,
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000381 srcData, rowBytes,
robertphillips@google.comf2e93fc2012-09-05 19:44:18 +0000382 GrTexture::NeedsFiltering(resourceKey)));
bsalomon@google.com27847de2011-02-22 20:59:41 +0000383 } else {
robertphillips@google.comf2e93fc2012-09-05 19:44:18 +0000384 texture.reset(fGpu->createTexture(desc, srcData, rowBytes));
bsalomon@google.com27847de2011-02-22 20:59:41 +0000385 }
robertphillips@google.com3319f332012-08-13 18:00:36 +0000386
387 if (NULL != texture) {
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000388 fTextureCache->create(resourceKey, texture);
robertphillips@google.com3319f332012-08-13 18:00:36 +0000389 }
390
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000391 return texture;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000392}
393
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000394GrTexture* GrContext::lockScratchTexture(const GrTextureDesc& inDesc,
395 ScratchTexMatch match) {
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000396 GrTextureDesc desc = inDesc;
robertphillips@google.com9c2ea842012-08-13 17:47:59 +0000397 GrCacheData cacheData(GrCacheData::kScratch_CacheID);
robertphillips@google.com75b3c962012-06-07 12:08:45 +0000398
rileya@google.com2afb8ec2012-08-23 14:08:57 +0000399 GrAssert((desc.fFlags & kRenderTarget_GrTextureFlagBit) ||
400 !(desc.fFlags & kNoStencil_GrTextureFlagBit));
401
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000402 if (kExact_ScratchTexMatch != match) {
403 // bin by pow2 with a reasonable min
404 static const int MIN_SIZE = 256;
405 desc.fWidth = GrMax(MIN_SIZE, GrNextPow2(desc.fWidth));
406 desc.fHeight = GrMax(MIN_SIZE, GrNextPow2(desc.fHeight));
407 }
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000408
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000409 GrResource* resource = NULL;
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000410 int origWidth = desc.fWidth;
411 int origHeight = desc.fHeight;
412 bool doubledW = false;
413 bool doubledH = false;
414
415 do {
robertphillips@google.com9c2ea842012-08-13 17:47:59 +0000416 GrResourceKey key = GrTexture::ComputeKey(fGpu, NULL, desc, cacheData, true);
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000417 resource = fTextureCache->find(key);
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000418 // if we miss, relax the fit of the flags...
419 // then try doubling width... then height.
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000420 if (NULL != resource || kExact_ScratchTexMatch == match) {
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000421 break;
422 }
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000423 // We no longer try to reuse textures that were previously used as render targets in
rileya@google.com2afb8ec2012-08-23 14:08:57 +0000424 // situations where no RT is needed; doing otherwise can confuse the video driver and
425 // cause significant performance problems in some cases.
426 if (desc.fFlags & kNoStencil_GrTextureFlagBit) {
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000427 desc.fFlags = desc.fFlags & ~kNoStencil_GrTextureFlagBit;
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000428 } else if (!doubledW) {
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000429 desc.fFlags = inDesc.fFlags;
430 desc.fWidth *= 2;
431 doubledW = true;
432 } else if (!doubledH) {
433 desc.fFlags = inDesc.fFlags;
434 desc.fWidth = origWidth;
435 desc.fHeight *= 2;
436 doubledH = true;
437 } else {
438 break;
439 }
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000440
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000441 } while (true);
442
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000443 if (NULL == resource) {
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000444 desc.fFlags = inDesc.fFlags;
445 desc.fWidth = origWidth;
446 desc.fHeight = origHeight;
robertphillips@google.comf2e93fc2012-09-05 19:44:18 +0000447 SkAutoTUnref<GrTexture> texture(fGpu->createTexture(desc, NULL, 0));
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000448 if (NULL != texture) {
robertphillips@google.com75b3c962012-06-07 12:08:45 +0000449 GrResourceKey key = GrTexture::ComputeKey(fGpu, NULL,
robertphillips@google.coma1e57952012-06-04 20:05:28 +0000450 texture->desc(),
robertphillips@google.com9c2ea842012-08-13 17:47:59 +0000451 cacheData,
robertphillips@google.coma1e57952012-06-04 20:05:28 +0000452 true);
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000453 fTextureCache->create(key, texture);
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000454 resource = texture;
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000455 }
456 }
457
458 // If the caller gives us the same desc/sampler twice we don't want
459 // to return the same texture the second time (unless it was previously
robertphillips@google.com521eaf82012-08-22 11:03:19 +0000460 // released). So make it exclusive to hide it from future searches.
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000461 if (NULL != resource) {
robertphillips@google.com521eaf82012-08-22 11:03:19 +0000462 fTextureCache->makeExclusive(resource->getCacheEntry());
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000463 }
robertphillips@google.com521eaf82012-08-22 11:03:19 +0000464
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000465 return static_cast<GrTexture*>(resource);
bsalomon@google.comb5b31682011-06-16 18:05:35 +0000466}
467
robertphillips@google.com15c0fea2012-06-22 12:41:43 +0000468void GrContext::addExistingTextureToCache(GrTexture* texture) {
469
470 if (NULL == texture) {
471 return;
472 }
473
robertphillips@google.com521eaf82012-08-22 11:03:19 +0000474 // This texture should already have a cache entry since it was once
475 // attached
476 GrAssert(NULL != texture->getCacheEntry());
robertphillips@google.com9c2ea842012-08-13 17:47:59 +0000477
robertphillips@google.com521eaf82012-08-22 11:03:19 +0000478 // Conceptually, the cache entry is going to assume responsibility
479 // for the creation ref.
480 GrAssert(1 == texture->getRefCnt());
481
482 // Since this texture came from an AutoScratchTexture it should
483 // still be in the exclusive pile
484 fTextureCache->makeNonExclusive(texture->getCacheEntry());
485
robertphillips@google.com50a035d2012-09-07 19:44:33 +0000486 this->purgeCache();
robertphillips@google.com15c0fea2012-06-22 12:41:43 +0000487}
488
robertphillips@google.coma9b06232012-08-30 11:06:31 +0000489
robertphillips@google.com9fbcad02012-09-09 14:44:15 +0000490void GrContext::unlockScratchTexture(GrTexture* texture) {
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000491 ASSERT_OWNED_RESOURCE(texture);
492 GrAssert(NULL != texture->getCacheEntry());
493
bsalomon@google.com50398bf2011-07-26 20:45:30 +0000494 // If this is a scratch texture we detached it from the cache
495 // while it was locked (to avoid two callers simultaneously getting
496 // the same texture).
robertphillips@google.com1f47f4f2012-08-16 14:49:16 +0000497 if (GrTexture::IsScratchTexture(texture->getCacheEntry()->key())) {
robertphillips@google.com521eaf82012-08-22 11:03:19 +0000498 fTextureCache->makeNonExclusive(texture->getCacheEntry());
bsalomon@google.comfea37b52011-04-25 15:51:06 +0000499 }
bsalomon@google.com27847de2011-02-22 20:59:41 +0000500
robertphillips@google.com50a035d2012-09-07 19:44:33 +0000501 this->purgeCache();
502}
503
504void GrContext::purgeCache() {
robertphillips@google.comeb9b3e12012-09-11 12:50:53 +0000505 if (NULL != fTextureCache) {
506 fTextureCache->purgeAsNeeded();
507 }
robertphillips@google.com15c0fea2012-06-22 12:41:43 +0000508}
509
robertphillips@google.com75b3c962012-06-07 12:08:45 +0000510GrTexture* GrContext::createUncachedTexture(const GrTextureDesc& descIn,
bsalomon@google.com27847de2011-02-22 20:59:41 +0000511 void* srcData,
512 size_t rowBytes) {
robertphillips@google.com75b3c962012-06-07 12:08:45 +0000513 GrTextureDesc descCopy = descIn;
robertphillips@google.com75b3c962012-06-07 12:08:45 +0000514 return fGpu->createTexture(descCopy, srcData, rowBytes);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000515}
516
bsalomon@google.com07fc0d12012-06-22 15:15:59 +0000517void GrContext::getTextureCacheLimits(int* maxTextures,
518 size_t* maxTextureBytes) const {
519 fTextureCache->getLimits(maxTextures, maxTextureBytes);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000520}
521
bsalomon@google.com07fc0d12012-06-22 15:15:59 +0000522void GrContext::setTextureCacheLimits(int maxTextures, size_t maxTextureBytes) {
523 fTextureCache->setLimits(maxTextures, maxTextureBytes);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000524}
525
bsalomon@google.com91958362011-06-13 17:58:13 +0000526int GrContext::getMaxTextureSize() const {
bsalomon@google.comf6601872012-08-28 21:11:35 +0000527 return fGpu->getCaps().maxTextureSize();
bsalomon@google.com91958362011-06-13 17:58:13 +0000528}
529
530int GrContext::getMaxRenderTargetSize() const {
bsalomon@google.comf6601872012-08-28 21:11:35 +0000531 return fGpu->getCaps().maxRenderTargetSize();
bsalomon@google.com27847de2011-02-22 20:59:41 +0000532}
533
534///////////////////////////////////////////////////////////////////////////////
535
bsalomon@google.come269f212011-11-07 13:29:52 +0000536GrTexture* GrContext::createPlatformTexture(const GrPlatformTextureDesc& desc) {
537 return fGpu->createPlatformTexture(desc);
538}
539
540GrRenderTarget* GrContext::createPlatformRenderTarget(const GrPlatformRenderTargetDesc& desc) {
541 return fGpu->createPlatformRenderTarget(desc);
542}
543
bsalomon@google.com5877ffd2011-04-11 17:58:48 +0000544///////////////////////////////////////////////////////////////////////////////
545
bsalomon@google.comb8670992012-07-25 21:27:09 +0000546bool GrContext::supportsIndex8PixelConfig(const GrTextureParams* params,
bsalomon@google.com1f221a72011-08-23 20:54:07 +0000547 int width, int height) const {
bsalomon@google.com18c9c192011-09-22 21:01:31 +0000548 const GrDrawTarget::Caps& caps = fGpu->getCaps();
bsalomon@google.comf6601872012-08-28 21:11:35 +0000549 if (!caps.eightBitPaletteSupport()) {
bsalomon@google.com27847de2011-02-22 20:59:41 +0000550 return false;
551 }
552
bsalomon@google.com27847de2011-02-22 20:59:41 +0000553 bool isPow2 = GrIsPow2(width) && GrIsPow2(height);
554
555 if (!isPow2) {
bsalomon@google.comb8670992012-07-25 21:27:09 +0000556 bool tiled = NULL != params && params->isTiled();
bsalomon@google.comf6601872012-08-28 21:11:35 +0000557 if (tiled && !caps.npotTextureTileSupport()) {
bsalomon@google.com27847de2011-02-22 20:59:41 +0000558 return false;
559 }
560 }
561 return true;
562}
563
564////////////////////////////////////////////////////////////////////////////////
565
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000566const GrClipData* GrContext::getClip() const {
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000567 return fGpu->getClip();
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000568}
bsalomon@google.com05ef5102011-05-02 21:14:59 +0000569
robertphillips@google.combeb1af72012-07-26 18:52:16 +0000570void GrContext::setClip(const GrClipData* clipData) {
571 fGpu->setClip(clipData);
robertphillips@google.com837ec432012-10-04 17:57:05 +0000572
bsalomon@google.comd5d69ff2012-10-04 19:42:00 +0000573 fDrawState->setState(GrDrawState::kClip_StateBit, !clipData->fClipStack->isWideOpen());
bsalomon@google.com27847de2011-02-22 20:59:41 +0000574}
575
bsalomon@google.com27847de2011-02-22 20:59:41 +0000576////////////////////////////////////////////////////////////////////////////////
577
bsalomon@google.com07ea2db2012-08-17 14:06:49 +0000578void GrContext::clear(const GrIRect* rect,
579 const GrColor color,
robertphillips@google.comc82a8b72012-06-21 20:15:48 +0000580 GrRenderTarget* target) {
bsalomon@google.com07ea2db2012-08-17 14:06:49 +0000581 this->prepareToDraw(NULL, DEFAULT_BUFFERING)->clear(rect, color, target);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000582}
583
584void GrContext::drawPaint(const GrPaint& paint) {
585 // set rect to be big enough to fill the space, but not super-huge, so we
586 // don't overflow fixed-point implementations
bsalomon@google.comd302f142011-03-03 13:54:13 +0000587 GrRect r;
588 r.setLTRB(0, 0,
589 GrIntToScalar(getRenderTarget()->width()),
590 GrIntToScalar(getRenderTarget()->height()));
bsalomon@google.com27847de2011-02-22 20:59:41 +0000591 GrMatrix inverse;
bsalomon@google.com8c2fe992011-09-13 15:27:18 +0000592 SkTLazy<GrPaint> tmpPaint;
593 const GrPaint* p = &paint;
robertphillips@google.comfea85ac2012-07-11 18:53:23 +0000594 AutoMatrix am;
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000595
bsalomon@google.com4f83be82011-09-12 13:52:51 +0000596 // We attempt to map r by the inverse matrix and draw that. mapRect will
597 // map the four corners and bound them with a new rect. This will not
598 // produce a correct result for some perspective matrices.
bsalomon@google.com8c2fe992011-09-13 15:27:18 +0000599 if (!this->getMatrix().hasPerspective()) {
bsalomon@google.com10e04bf2012-03-30 14:35:04 +0000600 if (!fDrawState->getViewInverse(&inverse)) {
bsalomon@google.come3d32162012-07-20 13:37:06 +0000601 GrPrintf("Could not invert matrix\n");
bsalomon@google.com8c2fe992011-09-13 15:27:18 +0000602 return;
603 }
bsalomon@google.com27847de2011-02-22 20:59:41 +0000604 inverse.mapRect(&r);
605 } else {
bsalomon@google.com88becf42012-10-05 14:54:42 +0000606 if (paint.hasStage()) {
bsalomon@google.com8c2fe992011-09-13 15:27:18 +0000607 tmpPaint.set(paint);
bsalomon@google.com8c2fe992011-09-13 15:27:18 +0000608 p = tmpPaint.get();
bsalomon@google.come3d32162012-07-20 13:37:06 +0000609 if (!tmpPaint.get()->preConcatSamplerMatricesWithInverse(fDrawState->getViewMatrix())) {
610 GrPrintf("Could not invert matrix\n");
611 }
bsalomon@google.com8c2fe992011-09-13 15:27:18 +0000612 }
bsalomon@google.com4f83be82011-09-12 13:52:51 +0000613 am.set(this, GrMatrix::I());
bsalomon@google.com27847de2011-02-22 20:59:41 +0000614 }
bsalomon@google.com4f83be82011-09-12 13:52:51 +0000615 // by definition this fills the entire clip, no need for AA
bsalomon@google.comc7448ce2012-10-05 19:04:13 +0000616 if (paint.isAntiAlias()) {
bsalomon@google.com8c2fe992011-09-13 15:27:18 +0000617 if (!tmpPaint.isValid()) {
618 tmpPaint.set(paint);
619 p = tmpPaint.get();
620 }
621 GrAssert(p == tmpPaint.get());
bsalomon@google.comc7448ce2012-10-05 19:04:13 +0000622 tmpPaint.get()->setAntiAlias(false);
bsalomon@google.com4f83be82011-09-12 13:52:51 +0000623 }
624 this->drawRect(*p, r);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000625}
626
bsalomon@google.com205d4602011-04-25 12:43:45 +0000627////////////////////////////////////////////////////////////////////////////////
628
bsalomon@google.comd46e2422011-09-23 17:40:07 +0000629namespace {
630inline bool disable_coverage_aa_for_blend(GrDrawTarget* target) {
631 return DISABLE_COVERAGE_AA_FOR_BLEND && !target->canApplyCoverage();
632}
633}
634
bsalomon@google.com06afe7b2011-04-26 15:31:40 +0000635////////////////////////////////////////////////////////////////////////////////
636
bsalomon@google.com27847de2011-02-22 20:59:41 +0000637/* create a triangle strip that strokes the specified triangle. There are 8
638 unique vertices, but we repreat the last 2 to close up. Alternatively we
639 could use an indices array, and then only send 8 verts, but not sure that
640 would be faster.
641 */
bsalomon@google.com205d4602011-04-25 12:43:45 +0000642static void setStrokeRectStrip(GrPoint verts[10], GrRect rect,
bsalomon@google.com27847de2011-02-22 20:59:41 +0000643 GrScalar width) {
644 const GrScalar rad = GrScalarHalf(width);
bsalomon@google.com205d4602011-04-25 12:43:45 +0000645 rect.sort();
bsalomon@google.com27847de2011-02-22 20:59:41 +0000646
647 verts[0].set(rect.fLeft + rad, rect.fTop + rad);
648 verts[1].set(rect.fLeft - rad, rect.fTop - rad);
649 verts[2].set(rect.fRight - rad, rect.fTop + rad);
650 verts[3].set(rect.fRight + rad, rect.fTop - rad);
651 verts[4].set(rect.fRight - rad, rect.fBottom - rad);
652 verts[5].set(rect.fRight + rad, rect.fBottom + rad);
653 verts[6].set(rect.fLeft + rad, rect.fBottom - rad);
654 verts[7].set(rect.fLeft - rad, rect.fBottom + rad);
655 verts[8] = verts[0];
656 verts[9] = verts[1];
657}
658
reed@google.com20efde72011-05-09 17:00:02 +0000659/**
660 * Returns true if the rects edges are integer-aligned.
661 */
662static bool isIRect(const GrRect& r) {
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000663 return GrScalarIsInt(r.fLeft) && GrScalarIsInt(r.fTop) &&
reed@google.com20efde72011-05-09 17:00:02 +0000664 GrScalarIsInt(r.fRight) && GrScalarIsInt(r.fBottom);
665}
666
bsalomon@google.com205d4602011-04-25 12:43:45 +0000667static bool apply_aa_to_rect(GrDrawTarget* target,
bsalomon@google.com205d4602011-04-25 12:43:45 +0000668 const GrRect& rect,
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000669 GrScalar width,
bsalomon@google.com205d4602011-04-25 12:43:45 +0000670 const GrMatrix* matrix,
671 GrMatrix* combinedMatrix,
bsalomon@google.coma3108262011-10-10 14:08:47 +0000672 GrRect* devRect,
673 bool* useVertexCoverage) {
bsalomon@google.com2eba7952012-01-12 13:47:37 +0000674 // we use a simple coverage ramp to do aa on axis-aligned rects
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000675 // we check if the rect will be axis-aligned, and the rect won't land on
bsalomon@google.com2eba7952012-01-12 13:47:37 +0000676 // integer coords.
bsalomon@google.comd46e2422011-09-23 17:40:07 +0000677
bsalomon@google.coma3108262011-10-10 14:08:47 +0000678 // we are keeping around the "tweak the alpha" trick because
679 // it is our only hope for the fixed-pipe implementation.
680 // In a shader implementation we can give a separate coverage input
bsalomon@google.com289533a2011-10-27 12:34:25 +0000681 // TODO: remove this ugliness when we drop the fixed-pipe impl
bsalomon@google.coma3108262011-10-10 14:08:47 +0000682 *useVertexCoverage = false;
bsalomon@google.comd46e2422011-09-23 17:40:07 +0000683 if (!target->canTweakAlphaForCoverage()) {
bsalomon@google.com2eba7952012-01-12 13:47:37 +0000684 if (disable_coverage_aa_for_blend(target)) {
bsalomon@google.com1983f392011-10-10 15:17:58 +0000685#if GR_DEBUG
bsalomon@google.com2eba7952012-01-12 13:47:37 +0000686 //GrPrintf("Turning off AA to correctly apply blend.\n");
bsalomon@google.com1983f392011-10-10 15:17:58 +0000687#endif
bsalomon@google.coma3108262011-10-10 14:08:47 +0000688 return false;
bsalomon@google.com2eba7952012-01-12 13:47:37 +0000689 } else {
690 *useVertexCoverage = true;
bsalomon@google.coma3108262011-10-10 14:08:47 +0000691 }
bsalomon@google.com205d4602011-04-25 12:43:45 +0000692 }
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000693 const GrDrawState& drawState = target->getDrawState();
694 if (drawState.getRenderTarget()->isMultisampled()) {
bsalomon@google.com205d4602011-04-25 12:43:45 +0000695 return false;
696 }
697
bsalomon@google.com471d4712011-08-23 15:45:25 +0000698 if (0 == width && target->willUseHWAALines()) {
bsalomon@google.com205d4602011-04-25 12:43:45 +0000699 return false;
700 }
701
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000702 if (!drawState.getViewMatrix().preservesAxisAlignment()) {
bsalomon@google.com205d4602011-04-25 12:43:45 +0000703 return false;
704 }
705
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000706 if (NULL != matrix &&
bsalomon@google.com205d4602011-04-25 12:43:45 +0000707 !matrix->preservesAxisAlignment()) {
708 return false;
709 }
710
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000711 *combinedMatrix = drawState.getViewMatrix();
bsalomon@google.com205d4602011-04-25 12:43:45 +0000712 if (NULL != matrix) {
713 combinedMatrix->preConcat(*matrix);
714 GrAssert(combinedMatrix->preservesAxisAlignment());
715 }
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000716
bsalomon@google.com205d4602011-04-25 12:43:45 +0000717 combinedMatrix->mapRect(devRect, rect);
718 devRect->sort();
719
720 if (width < 0) {
reed@google.com20efde72011-05-09 17:00:02 +0000721 return !isIRect(*devRect);
bsalomon@google.com205d4602011-04-25 12:43:45 +0000722 } else {
723 return true;
724 }
725}
726
bsalomon@google.com27847de2011-02-22 20:59:41 +0000727void GrContext::drawRect(const GrPaint& paint,
728 const GrRect& rect,
729 GrScalar width,
730 const GrMatrix* matrix) {
tomhudson@google.com278cbb42011-06-30 19:37:01 +0000731 SK_TRACE_EVENT0("GrContext::drawRect");
bsalomon@google.com27847de2011-02-22 20:59:41 +0000732
bsalomon@google.com07ea2db2012-08-17 14:06:49 +0000733 GrDrawTarget* target = this->prepareToDraw(&paint, DEFAULT_BUFFERING);
tomhudson@google.com7d6afdd2012-06-22 20:10:50 +0000734 GrDrawState::AutoStageDisable atr(fDrawState);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000735
bsalomon@google.com205d4602011-04-25 12:43:45 +0000736 GrRect devRect = rect;
737 GrMatrix combinedMatrix;
bsalomon@google.coma3108262011-10-10 14:08:47 +0000738 bool useVertexCoverage;
bsalomon@google.comc7448ce2012-10-05 19:04:13 +0000739 bool needAA = paint.isAntiAlias() &&
bsalomon@google.com289533a2011-10-27 12:34:25 +0000740 !this->getRenderTarget()->isMultisampled();
741 bool doAA = needAA && apply_aa_to_rect(target, rect, width, matrix,
742 &combinedMatrix, &devRect,
743 &useVertexCoverage);
bsalomon@google.com205d4602011-04-25 12:43:45 +0000744
745 if (doAA) {
bsalomon@google.com5b3e8902012-10-05 20:13:28 +0000746 GrDrawState::AutoDeviceCoordDraw adcd(target->drawState());
bsalomon@google.come3d32162012-07-20 13:37:06 +0000747 if (!adcd.succeeded()) {
748 return;
749 }
bsalomon@google.com205d4602011-04-25 12:43:45 +0000750 if (width >= 0) {
751 GrVec strokeSize;;
752 if (width > 0) {
753 strokeSize.set(width, width);
bsalomon@google.comcc4dac32011-05-10 13:52:42 +0000754 combinedMatrix.mapVectors(&strokeSize, 1);
bsalomon@google.com205d4602011-04-25 12:43:45 +0000755 strokeSize.setAbs(strokeSize);
756 } else {
757 strokeSize.set(GR_Scalar1, GR_Scalar1);
758 }
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000759 fAARectRenderer->strokeAARect(this->getGpu(), target, devRect,
robertphillips@google.comf6747b02012-06-12 00:32:28 +0000760 strokeSize, useVertexCoverage);
bsalomon@google.com205d4602011-04-25 12:43:45 +0000761 } else {
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000762 fAARectRenderer->fillAARect(this->getGpu(), target,
robertphillips@google.comf6747b02012-06-12 00:32:28 +0000763 devRect, useVertexCoverage);
bsalomon@google.com205d4602011-04-25 12:43:45 +0000764 }
765 return;
766 }
767
bsalomon@google.com27847de2011-02-22 20:59:41 +0000768 if (width >= 0) {
769 // TODO: consider making static vertex buffers for these cases.
770 // Hairline could be done by just adding closing vertex to
771 // unitSquareVertexBuffer()
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +0000772
bsalomon@google.com27847de2011-02-22 20:59:41 +0000773 static const int worstCaseVertCount = 10;
bsalomon@google.come3d32162012-07-20 13:37:06 +0000774 GrDrawTarget::AutoReleaseGeometry geo(target, 0, worstCaseVertCount, 0);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000775
776 if (!geo.succeeded()) {
bsalomon@google.com6513cd02011-08-05 20:12:30 +0000777 GrPrintf("Failed to get space for vertices!\n");
bsalomon@google.com27847de2011-02-22 20:59:41 +0000778 return;
779 }
780
781 GrPrimitiveType primType;
782 int vertCount;
783 GrPoint* vertex = geo.positions();
784
785 if (width > 0) {
786 vertCount = 10;
bsalomon@google.com47059542012-06-06 20:51:20 +0000787 primType = kTriangleStrip_GrPrimitiveType;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000788 setStrokeRectStrip(vertex, rect, width);
789 } else {
790 // hairline
791 vertCount = 5;
bsalomon@google.com47059542012-06-06 20:51:20 +0000792 primType = kLineStrip_GrPrimitiveType;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000793 vertex[0].set(rect.fLeft, rect.fTop);
794 vertex[1].set(rect.fRight, rect.fTop);
795 vertex[2].set(rect.fRight, rect.fBottom);
796 vertex[3].set(rect.fLeft, rect.fBottom);
797 vertex[4].set(rect.fLeft, rect.fTop);
798 }
799
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000800 GrDrawState::AutoViewMatrixRestore avmr;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000801 if (NULL != matrix) {
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000802 GrDrawState* drawState = target->drawState();
803 avmr.set(drawState);
804 drawState->preConcatViewMatrix(*matrix);
bsalomon@google.come3d32162012-07-20 13:37:06 +0000805 drawState->preConcatSamplerMatrices(*matrix);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000806 }
807
808 target->drawNonIndexed(primType, 0, vertCount);
809 } else {
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000810#if GR_STATIC_RECT_VB
bsalomon@google.com6513cd02011-08-05 20:12:30 +0000811 const GrVertexBuffer* sqVB = fGpu->getUnitSquareVertexBuffer();
812 if (NULL == sqVB) {
813 GrPrintf("Failed to create static rect vb.\n");
814 return;
815 }
bsalomon@google.come3d32162012-07-20 13:37:06 +0000816 target->setVertexSourceToBuffer(0, sqVB);
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000817 GrDrawState* drawState = target->drawState();
818 GrDrawState::AutoViewMatrixRestore avmr(drawState);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000819 GrMatrix m;
bsalomon@google.com8295dc12011-05-02 12:53:34 +0000820 m.setAll(rect.width(), 0, rect.fLeft,
bsalomon@google.com205d4602011-04-25 12:43:45 +0000821 0, rect.height(), rect.fTop,
822 0, 0, GrMatrix::I()[8]);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000823
824 if (NULL != matrix) {
825 m.postConcat(*matrix);
826 }
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000827 drawState->preConcatViewMatrix(m);
bsalomon@google.come3d32162012-07-20 13:37:06 +0000828 drawState->preConcatSamplerMatrices(m);
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000829
bsalomon@google.com47059542012-06-06 20:51:20 +0000830 target->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4);
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000831#else
bsalomon@google.come3d32162012-07-20 13:37:06 +0000832 target->drawSimpleRect(rect, matrix);
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000833#endif
bsalomon@google.com27847de2011-02-22 20:59:41 +0000834 }
835}
836
837void GrContext::drawRectToRect(const GrPaint& paint,
838 const GrRect& dstRect,
839 const GrRect& srcRect,
840 const GrMatrix* dstMatrix,
841 const GrMatrix* srcMatrix) {
tomhudson@google.com278cbb42011-06-30 19:37:01 +0000842 SK_TRACE_EVENT0("GrContext::drawRectToRect");
bsalomon@google.com27847de2011-02-22 20:59:41 +0000843
bsalomon@google.com88becf42012-10-05 14:54:42 +0000844 // srcRect refers to paint's first color stage
845 if (!paint.isColorStageEnabled(0)) {
bsalomon@google.com27847de2011-02-22 20:59:41 +0000846 drawRect(paint, dstRect, -1, dstMatrix);
847 return;
848 }
bsalomon@google.comde6ac2d2011-02-25 21:50:42 +0000849
bsalomon@google.com07ea2db2012-08-17 14:06:49 +0000850 GrDrawTarget* target = this->prepareToDraw(&paint, DEFAULT_BUFFERING);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000851
852#if GR_STATIC_RECT_VB
tomhudson@google.com7d6afdd2012-06-22 20:10:50 +0000853 GrDrawState::AutoStageDisable atr(fDrawState);
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000854 GrDrawState* drawState = target->drawState();
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000855 GrDrawState::AutoViewMatrixRestore avmr(drawState);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000856
857 GrMatrix m;
858
859 m.setAll(dstRect.width(), 0, dstRect.fLeft,
860 0, dstRect.height(), dstRect.fTop,
861 0, 0, GrMatrix::I()[8]);
862 if (NULL != dstMatrix) {
863 m.postConcat(*dstMatrix);
864 }
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +0000865 drawState->preConcatViewMatrix(m);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000866
bsalomon@google.come3d32162012-07-20 13:37:06 +0000867 // we explicitly setup the correct coords for the first stage. The others
868 // must know about the view matrix change.
869 for (int s = 1; s < GrPaint::kTotalStages; ++s) {
870 if (drawState->isStageEnabled(s)) {
871 drawState->sampler(s)->preConcatMatrix(m);
872 }
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +0000873 }
874
bsalomon@google.com27847de2011-02-22 20:59:41 +0000875 m.setAll(srcRect.width(), 0, srcRect.fLeft,
876 0, srcRect.height(), srcRect.fTop,
877 0, 0, GrMatrix::I()[8]);
878 if (NULL != srcMatrix) {
879 m.postConcat(*srcMatrix);
880 }
bsalomon@google.com903a4e22012-10-05 18:08:27 +0000881 drawState->sampler(GrPaint::kFirstColorStage)->preConcatMatrix(m);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000882
bsalomon@google.com6513cd02011-08-05 20:12:30 +0000883 const GrVertexBuffer* sqVB = fGpu->getUnitSquareVertexBuffer();
884 if (NULL == sqVB) {
885 GrPrintf("Failed to create static rect vb.\n");
886 return;
887 }
bsalomon@google.come3d32162012-07-20 13:37:06 +0000888 target->setVertexSourceToBuffer(0, sqVB);
bsalomon@google.com47059542012-06-06 20:51:20 +0000889 target->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000890#else
tomhudson@google.com7d6afdd2012-06-22 20:10:50 +0000891 GrDrawState::AutoStageDisable atr(fDrawState);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000892
tomhudson@google.com93813632011-10-27 20:21:16 +0000893 const GrRect* srcRects[GrDrawState::kNumStages] = {NULL};
894 const GrMatrix* srcMatrices[GrDrawState::kNumStages] = {NULL};
bsalomon@google.com27847de2011-02-22 20:59:41 +0000895 srcRects[0] = &srcRect;
896 srcMatrices[0] = srcMatrix;
897
bsalomon@google.come3d32162012-07-20 13:37:06 +0000898 target->drawRect(dstRect, dstMatrix, srcRects, srcMatrices);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000899#endif
900}
901
902void GrContext::drawVertices(const GrPaint& paint,
903 GrPrimitiveType primitiveType,
904 int vertexCount,
905 const GrPoint positions[],
906 const GrPoint texCoords[],
907 const GrColor colors[],
908 const uint16_t indices[],
909 int indexCount) {
tomhudson@google.com278cbb42011-06-30 19:37:01 +0000910 SK_TRACE_EVENT0("GrContext::drawVertices");
bsalomon@google.com27847de2011-02-22 20:59:41 +0000911
912 GrDrawTarget::AutoReleaseGeometry geo;
913
bsalomon@google.com07ea2db2012-08-17 14:06:49 +0000914 GrDrawTarget* target = this->prepareToDraw(&paint, DEFAULT_BUFFERING);
tomhudson@google.com7d6afdd2012-06-22 20:10:50 +0000915 GrDrawState::AutoStageDisable atr(fDrawState);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000916
bsalomon@google.come3d32162012-07-20 13:37:06 +0000917 GrVertexLayout layout = 0;
918 if (NULL != texCoords) {
919 layout |= GrDrawTarget::StageTexCoordVertexLayoutBit(0, 0);
920 }
bsalomon@google.com27847de2011-02-22 20:59:41 +0000921 if (NULL != colors) {
922 layout |= GrDrawTarget::kColor_VertexLayoutBit;
bsalomon@google.com27847de2011-02-22 20:59:41 +0000923 }
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +0000924 int vertexSize = GrDrawTarget::VertexSize(layout);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000925
926 if (sizeof(GrPoint) != vertexSize) {
927 if (!geo.set(target, layout, vertexCount, 0)) {
bsalomon@google.com6513cd02011-08-05 20:12:30 +0000928 GrPrintf("Failed to get space for vertices!\n");
bsalomon@google.com27847de2011-02-22 20:59:41 +0000929 return;
930 }
tomhudson@google.com93813632011-10-27 20:21:16 +0000931 int texOffsets[GrDrawState::kMaxTexCoords];
bsalomon@google.com27847de2011-02-22 20:59:41 +0000932 int colorOffset;
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +0000933 GrDrawTarget::VertexSizeAndOffsetsByIdx(layout,
934 texOffsets,
bsalomon@google.comaeb21602011-08-30 18:13:44 +0000935 &colorOffset,
bsalomon@google.coma3108262011-10-10 14:08:47 +0000936 NULL,
937 NULL);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000938 void* curVertex = geo.vertices();
939
940 for (int i = 0; i < vertexCount; ++i) {
941 *((GrPoint*)curVertex) = positions[i];
942
943 if (texOffsets[0] > 0) {
944 *(GrPoint*)((intptr_t)curVertex + texOffsets[0]) = texCoords[i];
945 }
946 if (colorOffset > 0) {
947 *(GrColor*)((intptr_t)curVertex + colorOffset) = colors[i];
948 }
bsalomon@google.com26c2d0a2011-05-17 20:15:30 +0000949 curVertex = (void*)((intptr_t)curVertex + vertexSize);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000950 }
951 } else {
952 target->setVertexSourceToArray(layout, positions, vertexCount);
953 }
954
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000955 // we don't currently apply offscreen AA to this path. Need improved
bsalomon@google.com91958362011-06-13 17:58:13 +0000956 // management of GrDrawTarget's geometry to avoid copying points per-tile.
bsalomon@google.coma47a48d2011-04-26 20:22:11 +0000957
bsalomon@google.com8295dc12011-05-02 12:53:34 +0000958 if (NULL != indices) {
bsalomon@google.com91958362011-06-13 17:58:13 +0000959 target->setIndexSourceToArray(indices, indexCount);
bsalomon@google.com8295dc12011-05-02 12:53:34 +0000960 target->drawIndexed(primitiveType, 0, 0, vertexCount, indexCount);
bsalomon@google.com27847de2011-02-22 20:59:41 +0000961 } else {
bsalomon@google.com8295dc12011-05-02 12:53:34 +0000962 target->drawNonIndexed(primitiveType, 0, vertexCount);
963 }
bsalomon@google.com27847de2011-02-22 20:59:41 +0000964}
965
bsalomon@google.com06afe7b2011-04-26 15:31:40 +0000966///////////////////////////////////////////////////////////////////////////////
bsalomon@google.com150d2842012-01-12 20:19:56 +0000967namespace {
968
bsalomon@google.com93c96602012-04-27 13:05:21 +0000969struct CircleVertex {
970 GrPoint fPos;
971 GrPoint fCenter;
972 GrScalar fOuterRadius;
973 GrScalar fInnerRadius;
974};
975
976/* Returns true if will map a circle to another circle. This can be true
977 * if the matrix only includes square-scale, rotation, translation.
978 */
979inline bool isSimilarityTransformation(const SkMatrix& matrix,
980 SkScalar tol = SK_ScalarNearlyZero) {
981 if (matrix.isIdentity() || matrix.getType() == SkMatrix::kTranslate_Mask) {
982 return true;
983 }
984 if (matrix.hasPerspective()) {
985 return false;
986 }
987
988 SkScalar mx = matrix.get(SkMatrix::kMScaleX);
989 SkScalar sx = matrix.get(SkMatrix::kMSkewX);
990 SkScalar my = matrix.get(SkMatrix::kMScaleY);
991 SkScalar sy = matrix.get(SkMatrix::kMSkewY);
992
993 if (mx == 0 && sx == 0 && my == 0 && sy == 0) {
994 return false;
995 }
996
997 // it has scales or skews, but it could also be rotation, check it out.
998 SkVector vec[2];
999 vec[0].set(mx, sx);
1000 vec[1].set(sy, my);
1001
1002 return SkScalarNearlyZero(vec[0].dot(vec[1]), SkScalarSquare(tol)) &&
1003 SkScalarNearlyEqual(vec[0].lengthSqd(), vec[1].lengthSqd(),
1004 SkScalarSquare(tol));
1005}
1006
1007}
1008
1009// TODO: strokeWidth can't be larger than zero right now.
1010// It will be fixed when drawPath() can handle strokes.
1011void GrContext::drawOval(const GrPaint& paint,
1012 const GrRect& rect,
1013 SkScalar strokeWidth) {
bsalomon@google.com0982d352012-07-31 15:33:25 +00001014 GrAssert(strokeWidth <= 0);
1015 if (!isSimilarityTransformation(this->getMatrix()) ||
bsalomon@google.comc7448ce2012-10-05 19:04:13 +00001016 !paint.isAntiAlias() ||
bsalomon@google.com93c96602012-04-27 13:05:21 +00001017 rect.height() != rect.width()) {
1018 SkPath path;
1019 path.addOval(rect);
1020 GrPathFill fill = (strokeWidth == 0) ?
bsalomon@google.com0982d352012-07-31 15:33:25 +00001021 kHairLine_GrPathFill : kWinding_GrPathFill;
bsalomon@google.com93c96602012-04-27 13:05:21 +00001022 this->internalDrawPath(paint, path, fill, NULL);
1023 return;
1024 }
1025
bsalomon@google.com07ea2db2012-08-17 14:06:49 +00001026 GrDrawTarget* target = this->prepareToDraw(&paint, DEFAULT_BUFFERING);
1027
bsalomon@google.com0982d352012-07-31 15:33:25 +00001028 GrDrawState* drawState = target->drawState();
1029 GrDrawState::AutoStageDisable atr(fDrawState);
1030 const GrMatrix vm = drawState->getViewMatrix();
1031
bsalomon@google.com93c96602012-04-27 13:05:21 +00001032 const GrRenderTarget* rt = drawState->getRenderTarget();
1033 if (NULL == rt) {
1034 return;
1035 }
1036
bsalomon@google.com5b3e8902012-10-05 20:13:28 +00001037 GrDrawState::AutoDeviceCoordDraw adcd(drawState);
bsalomon@google.come3d32162012-07-20 13:37:06 +00001038 if (!adcd.succeeded()) {
1039 return;
1040 }
bsalomon@google.com93c96602012-04-27 13:05:21 +00001041
bsalomon@google.come3d32162012-07-20 13:37:06 +00001042 GrVertexLayout layout = GrDrawTarget::kEdge_VertexLayoutBit;
bsalomon@google.com93c96602012-04-27 13:05:21 +00001043 GrAssert(sizeof(CircleVertex) == GrDrawTarget::VertexSize(layout));
1044
1045 GrPoint center = GrPoint::Make(rect.centerX(), rect.centerY());
1046 GrScalar radius = SkScalarHalf(rect.width());
1047
1048 vm.mapPoints(&center, 1);
1049 radius = vm.mapRadius(radius);
1050
1051 GrScalar outerRadius = radius;
1052 GrScalar innerRadius = 0;
1053 SkScalar halfWidth = 0;
1054 if (strokeWidth == 0) {
1055 halfWidth = SkScalarHalf(SK_Scalar1);
1056
1057 outerRadius += halfWidth;
1058 innerRadius = SkMaxScalar(0, radius - halfWidth);
1059 }
1060
1061 GrDrawTarget::AutoReleaseGeometry geo(target, layout, 4, 0);
1062 if (!geo.succeeded()) {
1063 GrPrintf("Failed to get space for vertices!\n");
1064 return;
1065 }
1066
1067 CircleVertex* verts = reinterpret_cast<CircleVertex*>(geo.vertices());
1068
robertphillips@google.coma0a66c12012-06-22 13:14:29 +00001069 // The fragment shader will extend the radius out half a pixel
1070 // to antialias. Expand the drawn rect here so all the pixels
1071 // will be captured.
1072 SkScalar L = center.fX - outerRadius - SkFloatToScalar(0.5f);
1073 SkScalar R = center.fX + outerRadius + SkFloatToScalar(0.5f);
1074 SkScalar T = center.fY - outerRadius - SkFloatToScalar(0.5f);
1075 SkScalar B = center.fY + outerRadius + SkFloatToScalar(0.5f);
bsalomon@google.com93c96602012-04-27 13:05:21 +00001076
1077 verts[0].fPos = SkPoint::Make(L, T);
1078 verts[1].fPos = SkPoint::Make(R, T);
1079 verts[2].fPos = SkPoint::Make(L, B);
1080 verts[3].fPos = SkPoint::Make(R, B);
1081
1082 for (int i = 0; i < 4; ++i) {
1083 // this goes to fragment shader, it should be in y-points-up space.
1084 verts[i].fCenter = SkPoint::Make(center.fX, rt->height() - center.fY);
1085
1086 verts[i].fOuterRadius = outerRadius;
1087 verts[i].fInnerRadius = innerRadius;
1088 }
1089
1090 drawState->setVertexEdgeType(GrDrawState::kCircle_EdgeType);
bsalomon@google.com47059542012-06-06 20:51:20 +00001091 target->drawNonIndexed(kTriangleStrip_GrPrimitiveType, 0, 4);
bsalomon@google.com150d2842012-01-12 20:19:56 +00001092}
bsalomon@google.com27847de2011-02-22 20:59:41 +00001093
bsalomon@google.com8d033a12012-04-27 15:52:53 +00001094void GrContext::drawPath(const GrPaint& paint, const SkPath& path,
reed@google.com07f3ee12011-05-16 17:21:57 +00001095 GrPathFill fill, const GrPoint* translate) {
bsalomon@google.com27847de2011-02-22 20:59:41 +00001096
bsalomon@google.comfa6ac932011-10-05 19:57:55 +00001097 if (path.isEmpty()) {
bsalomon@google.comfa6ac932011-10-05 19:57:55 +00001098 if (GrIsFillInverted(fill)) {
1099 this->drawPaint(paint);
1100 }
1101 return;
1102 }
1103
bsalomon@google.com93c96602012-04-27 13:05:21 +00001104 SkRect ovalRect;
1105 if (!GrIsFillInverted(fill) && path.isOval(&ovalRect)) {
1106 if (translate) {
1107 ovalRect.offset(*translate);
1108 }
bsalomon@google.com47059542012-06-06 20:51:20 +00001109 SkScalar width = (fill == kHairLine_GrPathFill) ? 0 : -SK_Scalar1;
bsalomon@google.com93c96602012-04-27 13:05:21 +00001110 this->drawOval(paint, ovalRect, width);
1111 return;
1112 }
1113
1114 internalDrawPath(paint, path, fill, translate);
1115}
1116
bsalomon@google.com8d033a12012-04-27 15:52:53 +00001117void GrContext::internalDrawPath(const GrPaint& paint, const SkPath& path,
bsalomon@google.com93c96602012-04-27 13:05:21 +00001118 GrPathFill fill, const GrPoint* translate) {
1119
bsalomon@google.comfb4ce6f2012-03-14 13:27:54 +00001120 // Note that below we may sw-rasterize the path into a scratch texture.
1121 // Scratch textures can be recycled after they are returned to the texture
1122 // cache. This presents a potential hazard for buffered drawing. However,
1123 // the writePixels that uploads to the scratch will perform a flush so we're
1124 // OK.
bsalomon@google.com07ea2db2012-08-17 14:06:49 +00001125 GrDrawTarget* target = this->prepareToDraw(&paint, DEFAULT_BUFFERING);
tomhudson@google.com7d6afdd2012-06-22 20:10:50 +00001126 GrDrawState::AutoStageDisable atr(fDrawState);
bsalomon@google.comd46e2422011-09-23 17:40:07 +00001127
bsalomon@google.comc7448ce2012-10-05 19:04:13 +00001128 bool prAA = paint.isAntiAlias() && !this->getRenderTarget()->isMultisampled();
bsalomon@google.com289533a2011-10-27 12:34:25 +00001129
bsalomon@google.comd46e2422011-09-23 17:40:07 +00001130 // An Assumption here is that path renderer would use some form of tweaking
1131 // the src color (either the input alpha or in the frag shader) to implement
1132 // aa. If we have some future driver-mojo path AA that can do the right
1133 // thing WRT to the blend then we'll need some query on the PR.
1134 if (disable_coverage_aa_for_blend(target)) {
bsalomon@google.com1983f392011-10-10 15:17:58 +00001135#if GR_DEBUG
bsalomon@google.com979432b2011-11-05 21:38:22 +00001136 //GrPrintf("Turning off AA to correctly apply blend.\n");
bsalomon@google.com1983f392011-10-10 15:17:58 +00001137#endif
bsalomon@google.com289533a2011-10-27 12:34:25 +00001138 prAA = false;
bsalomon@google.comd46e2422011-09-23 17:40:07 +00001139 }
bsalomon@google.com289533a2011-10-27 12:34:25 +00001140
robertphillips@google.com72176b22012-05-23 13:19:12 +00001141 GrPathRenderer* pr = this->getPathRenderer(path, fill, target, prAA, true);
bsalomon@google.com30085192011-08-19 15:42:31 +00001142 if (NULL == pr) {
bsalomon@google.com1983f392011-10-10 15:17:58 +00001143#if GR_DEBUG
bsalomon@google.com30085192011-08-19 15:42:31 +00001144 GrPrintf("Unable to find path renderer compatible with path.\n");
bsalomon@google.com1983f392011-10-10 15:17:58 +00001145#endif
bsalomon@google.com30085192011-08-19 15:42:31 +00001146 return;
1147 }
1148
bsalomon@google.come3d32162012-07-20 13:37:06 +00001149 pr->drawPath(path, fill, translate, target, prAA);
bsalomon@google.com27847de2011-02-22 20:59:41 +00001150}
bsalomon@google.com8295dc12011-05-02 12:53:34 +00001151
bsalomon@google.com27847de2011-02-22 20:59:41 +00001152////////////////////////////////////////////////////////////////////////////////
1153
bsalomon@google.coma7f84e12011-03-10 14:13:19 +00001154void GrContext::flush(int flagsBitfield) {
1155 if (kDiscard_FlushBit & flagsBitfield) {
1156 fDrawBuffer->reset();
1157 } else {
bsalomon@google.comc4364992011-11-07 15:54:49 +00001158 this->flushDrawBuffer();
bsalomon@google.coma7f84e12011-03-10 14:13:19 +00001159 }
bsalomon@google.coma7f84e12011-03-10 14:13:19 +00001160 if (kForceCurrentRenderTarget_FlushBit & flagsBitfield) {
bsalomon@google.com27847de2011-02-22 20:59:41 +00001161 fGpu->forceRenderTargetFlush();
1162 }
1163}
1164
bsalomon@google.com27847de2011-02-22 20:59:41 +00001165void GrContext::flushDrawBuffer() {
junov@google.com53a55842011-06-08 22:55:10 +00001166 if (fDrawBuffer) {
robertphillips@google.com58b38182012-05-03 16:29:41 +00001167 // With addition of the AA clip path, flushing the draw buffer can
1168 // result in the generation of an AA clip mask. During this
1169 // process the SW path renderer may be invoked which recusively
1170 // calls this method (via internalWriteTexturePixels) creating
1171 // infinite recursion
1172 GrInOrderDrawBuffer* temp = fDrawBuffer;
1173 fDrawBuffer = NULL;
1174
1175 temp->flushTo(fGpu);
1176
1177 fDrawBuffer = temp;
junov@google.com53a55842011-06-08 22:55:10 +00001178 }
bsalomon@google.com27847de2011-02-22 20:59:41 +00001179}
1180
bsalomon@google.com0342a852012-08-20 19:22:38 +00001181void GrContext::writeTexturePixels(GrTexture* texture,
1182 int left, int top, int width, int height,
1183 GrPixelConfig config, const void* buffer, size_t rowBytes,
1184 uint32_t flags) {
bsalomon@google.com6f379512011-11-16 20:36:03 +00001185 SK_TRACE_EVENT0("GrContext::writeTexturePixels");
bsalomon@google.combc4b6542011-11-19 13:56:11 +00001186 ASSERT_OWNED_RESOURCE(texture);
1187
bsalomon@google.com0342a852012-08-20 19:22:38 +00001188 // TODO: use scratch texture to perform conversion
1189 if (kUnpremul_PixelOpsFlag & flags) {
1190 return;
1191 }
bsalomon@google.com6f379512011-11-16 20:36:03 +00001192 if (!(kDontFlush_PixelOpsFlag & flags)) {
1193 this->flush();
1194 }
bsalomon@google.com6f379512011-11-16 20:36:03 +00001195
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001196 fGpu->writeTexturePixels(texture, left, top, width, height,
bsalomon@google.com6f379512011-11-16 20:36:03 +00001197 config, buffer, rowBytes);
1198}
1199
bsalomon@google.com0342a852012-08-20 19:22:38 +00001200bool GrContext::readTexturePixels(GrTexture* texture,
1201 int left, int top, int width, int height,
1202 GrPixelConfig config, void* buffer, size_t rowBytes,
1203 uint32_t flags) {
tomhudson@google.com278cbb42011-06-30 19:37:01 +00001204 SK_TRACE_EVENT0("GrContext::readTexturePixels");
bsalomon@google.combc4b6542011-11-19 13:56:11 +00001205 ASSERT_OWNED_RESOURCE(texture);
bsalomon@google.com669fdc42011-04-05 17:08:27 +00001206
bsalomon@google.coma85449d2011-11-19 02:36:05 +00001207 // TODO: code read pixels for textures that aren't also rendertargets
bsalomon@google.com669fdc42011-04-05 17:08:27 +00001208 GrRenderTarget* target = texture->asRenderTarget();
1209 if (NULL != target) {
bsalomon@google.com0342a852012-08-20 19:22:38 +00001210 return this->readRenderTargetPixels(target,
1211 left, top, width, height,
1212 config, buffer, rowBytes,
1213 flags);
bsalomon@google.com669fdc42011-04-05 17:08:27 +00001214 } else {
1215 return false;
1216 }
1217}
1218
bsalomon@google.coma91e9232012-02-23 15:39:54 +00001219#include "SkConfig8888.h"
1220
1221namespace {
1222/**
1223 * Converts a GrPixelConfig to a SkCanvas::Config8888. Only byte-per-channel
1224 * formats are representable as Config8888 and so the function returns false
1225 * if the GrPixelConfig has no equivalent Config8888.
1226 */
1227bool grconfig_to_config8888(GrPixelConfig config,
bsalomon@google.com0342a852012-08-20 19:22:38 +00001228 bool unpremul,
bsalomon@google.coma91e9232012-02-23 15:39:54 +00001229 SkCanvas::Config8888* config8888) {
1230 switch (config) {
bsalomon@google.com0342a852012-08-20 19:22:38 +00001231 case kRGBA_8888_GrPixelConfig:
1232 if (unpremul) {
1233 *config8888 = SkCanvas::kRGBA_Unpremul_Config8888;
1234 } else {
1235 *config8888 = SkCanvas::kRGBA_Premul_Config8888;
1236 }
bsalomon@google.coma91e9232012-02-23 15:39:54 +00001237 return true;
bsalomon@google.com0342a852012-08-20 19:22:38 +00001238 case kBGRA_8888_GrPixelConfig:
1239 if (unpremul) {
1240 *config8888 = SkCanvas::kBGRA_Unpremul_Config8888;
1241 } else {
1242 *config8888 = SkCanvas::kBGRA_Premul_Config8888;
1243 }
bsalomon@google.coma91e9232012-02-23 15:39:54 +00001244 return true;
1245 default:
1246 return false;
1247 }
1248}
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001249
1250// It returns a configuration with where the byte position of the R & B components are swapped in
1251// relation to the input config. This should only be called with the result of
1252// grconfig_to_config8888 as it will fail for other configs.
1253SkCanvas::Config8888 swap_config8888_red_and_blue(SkCanvas::Config8888 config8888) {
1254 switch (config8888) {
1255 case SkCanvas::kBGRA_Premul_Config8888:
1256 return SkCanvas::kRGBA_Premul_Config8888;
1257 case SkCanvas::kBGRA_Unpremul_Config8888:
1258 return SkCanvas::kRGBA_Unpremul_Config8888;
1259 case SkCanvas::kRGBA_Premul_Config8888:
1260 return SkCanvas::kBGRA_Premul_Config8888;
1261 case SkCanvas::kRGBA_Unpremul_Config8888:
1262 return SkCanvas::kBGRA_Unpremul_Config8888;
1263 default:
1264 GrCrash("Unexpected input");
1265 return SkCanvas::kBGRA_Unpremul_Config8888;;
1266 }
1267}
bsalomon@google.coma91e9232012-02-23 15:39:54 +00001268}
1269
bsalomon@google.com0342a852012-08-20 19:22:38 +00001270bool GrContext::readRenderTargetPixels(GrRenderTarget* target,
1271 int left, int top, int width, int height,
1272 GrPixelConfig config, void* buffer, size_t rowBytes,
1273 uint32_t flags) {
tomhudson@google.com278cbb42011-06-30 19:37:01 +00001274 SK_TRACE_EVENT0("GrContext::readRenderTargetPixels");
bsalomon@google.combc4b6542011-11-19 13:56:11 +00001275 ASSERT_OWNED_RESOURCE(target);
1276
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001277 if (NULL == target) {
bsalomon@google.com10e04bf2012-03-30 14:35:04 +00001278 target = fDrawState->getRenderTarget();
bsalomon@google.comc4364992011-11-07 15:54:49 +00001279 if (NULL == target) {
1280 return false;
1281 }
1282 }
bsalomon@google.com669fdc42011-04-05 17:08:27 +00001283
bsalomon@google.com6f379512011-11-16 20:36:03 +00001284 if (!(kDontFlush_PixelOpsFlag & flags)) {
1285 this->flush();
1286 }
bsalomon@google.comc4364992011-11-07 15:54:49 +00001287
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001288 // Determine which conversions have to be applied: flipY, swapRAnd, and/or unpremul.
bsalomon@google.com0342a852012-08-20 19:22:38 +00001289
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001290 // If fGpu->readPixels would incur a y-flip cost then we will read the pixels upside down. We'll
1291 // either do the flipY by drawing into a scratch with a matrix or on the cpu after the read.
1292 bool flipY = fGpu->readPixelsWillPayForYFlip(target, left, top,
bsalomon@google.comc4364992011-11-07 15:54:49 +00001293 width, height, config,
1294 rowBytes);
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001295 bool swapRAndB = fGpu->preferredReadPixelsConfig(config) == GrPixelConfigSwapRAndB(config);
1296
bsalomon@google.com0342a852012-08-20 19:22:38 +00001297 bool unpremul = SkToBool(kUnpremul_PixelOpsFlag & flags);
bsalomon@google.comc4364992011-11-07 15:54:49 +00001298
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001299 // flipY will get set to false when it is handled below using a scratch. However, in that case
1300 // we still want to do the read upside down.
1301 bool readUpsideDown = flipY;
1302
1303 if (unpremul && kRGBA_8888_GrPixelConfig != config && kBGRA_8888_GrPixelConfig != config) {
1304 // The unpremul flag is only allowed for these two configs.
bsalomon@google.com0a97be22011-11-08 19:20:57 +00001305 return false;
1306 }
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001307
1308 GrPixelConfig readConfig;
1309 if (swapRAndB) {
1310 readConfig = GrPixelConfigSwapRAndB(config);
1311 GrAssert(kUnknown_GrPixelConfig != config);
1312 } else {
1313 readConfig = config;
1314 }
1315
1316 // If the src is a texture and we would have to do conversions after read pixels, we instead
1317 // do the conversions by drawing the src to a scratch texture. If we handle any of the
1318 // conversions in the draw we set the corresponding bool to false so that we don't reapply it
1319 // on the read back pixels.
1320 GrTexture* src = target->asTexture();
bsalomon@google.comc4ff22a2011-11-10 21:56:21 +00001321 GrAutoScratchTexture ast;
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001322 if (NULL != src && (swapRAndB || unpremul || flipY)) {
1323 // Make the scratch a render target because we don't have a robust readTexturePixels as of
1324 // yet. It calls this function.
robertphillips@google.com75b3c962012-06-07 12:08:45 +00001325 GrTextureDesc desc;
1326 desc.fFlags = kRenderTarget_GrTextureFlagBit;
1327 desc.fWidth = width;
1328 desc.fHeight = height;
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001329 desc.fConfig = readConfig;
bsalomon@google.comc4ff22a2011-11-10 21:56:21 +00001330
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001331 // When a full readback is faster than a partial we could always make the scratch exactly
1332 // match the passed rect. However, if we see many different size rectangles we will trash
1333 // our texture cache and pay the cost of creating and destroying many textures. So, we only
1334 // request an exact match when the caller is reading an entire RT.
bsalomon@google.com56d11e02011-11-30 19:59:08 +00001335 ScratchTexMatch match = kApprox_ScratchTexMatch;
1336 if (0 == left &&
1337 0 == top &&
1338 target->width() == width &&
1339 target->height() == height &&
1340 fGpu->fullReadPixelsIsFasterThanPartial()) {
1341 match = kExact_ScratchTexMatch;
1342 }
1343 ast.set(this, desc, match);
bsalomon@google.comc4364992011-11-07 15:54:49 +00001344 GrTexture* texture = ast.texture();
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001345 if (texture) {
1346 SkAutoTUnref<GrCustomStage> stage;
1347 if (unpremul) {
1348 stage.reset(this->createPMToUPMEffect(src, swapRAndB));
1349 }
1350 // If we failed to create a PM->UPM effect and have no other conversions to perform then
1351 // there is no longer any point to using the scratch.
1352 if (NULL != stage || flipY || swapRAndB) {
1353 if (NULL == stage) {
1354 stage.reset(GrConfigConversionEffect::Create(src, swapRAndB));
1355 GrAssert(NULL != stage);
1356 } else {
1357 unpremul = false; // we will handle the UPM conversion in the draw
1358 }
1359 swapRAndB = false; // we will handle the swap in the draw.
bsalomon@google.comc4364992011-11-07 15:54:49 +00001360
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001361 GrDrawTarget::AutoStateRestore asr(fGpu, GrDrawTarget::kReset_ASRInit);
1362 GrDrawState* drawState = fGpu->drawState();
1363 drawState->setRenderTarget(texture->asRenderTarget());
1364 GrMatrix matrix;
1365 if (flipY) {
1366 matrix.setTranslate(SK_Scalar1 * left,
1367 SK_Scalar1 * (top + height));
1368 matrix.set(GrMatrix::kMScaleY, -GR_Scalar1);
1369 flipY = false; // the y flip will be handled in the draw
1370 } else {
1371 matrix.setTranslate(SK_Scalar1 *left, SK_Scalar1 *top);
1372 }
1373 matrix.postIDiv(src->width(), src->height());
1374 drawState->sampler(0)->reset(matrix);
1375 drawState->sampler(0)->setCustomStage(stage);
1376 GrRect rect = GrRect::MakeWH(GrIntToScalar(width), GrIntToScalar(height));
1377 fGpu->drawSimpleRect(rect, NULL);
1378 // we want to read back from the scratch's origin
1379 left = 0;
1380 top = 0;
1381 target = texture->asRenderTarget();
1382 }
bsalomon@google.com0342a852012-08-20 19:22:38 +00001383 }
bsalomon@google.comc4364992011-11-07 15:54:49 +00001384 }
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001385 if (!fGpu->readPixels(target,
1386 left, top, width, height,
1387 readConfig, buffer, rowBytes, readUpsideDown)) {
1388 return false;
1389 }
1390 // Perform any conversions we weren't able to perfom using a scratch texture.
1391 if (unpremul || swapRAndB || flipY) {
bsalomon@google.comccaa0022012-09-25 19:55:07 +00001392 // These are initialized to suppress a warning
1393 SkCanvas::Config8888 srcC8888 = SkCanvas::kNative_Premul_Config8888;
1394 SkCanvas::Config8888 dstC8888 = SkCanvas::kNative_Premul_Config8888;
1395
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001396 bool c8888IsValid = grconfig_to_config8888(config, false, &srcC8888);
1397 grconfig_to_config8888(config, unpremul, &dstC8888);
bsalomon@google.comccaa0022012-09-25 19:55:07 +00001398
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001399 if (swapRAndB) {
1400 GrAssert(c8888IsValid); // we should only do r/b swap on 8888 configs
1401 srcC8888 = swap_config8888_red_and_blue(srcC8888);
1402 }
1403 if (flipY) {
1404 size_t tightRB = width * GrBytesPerPixel(config);
1405 if (0 == rowBytes) {
1406 rowBytes = tightRB;
1407 }
1408 SkAutoSTMalloc<256, uint8_t> tempRow(tightRB);
1409 intptr_t top = reinterpret_cast<intptr_t>(buffer);
1410 intptr_t bot = top + (height - 1) * rowBytes;
1411 while (top < bot) {
1412 uint32_t* t = reinterpret_cast<uint32_t*>(top);
1413 uint32_t* b = reinterpret_cast<uint32_t*>(bot);
1414 uint32_t* temp = reinterpret_cast<uint32_t*>(tempRow.get());
1415 memcpy(temp, t, tightRB);
1416 if (c8888IsValid) {
1417 SkConvertConfig8888Pixels(t, tightRB, dstC8888,
1418 b, tightRB, srcC8888,
1419 width, 1);
1420 SkConvertConfig8888Pixels(b, tightRB, dstC8888,
1421 temp, tightRB, srcC8888,
1422 width, 1);
1423 } else {
1424 memcpy(t, b, tightRB);
1425 memcpy(b, temp, tightRB);
1426 }
1427 top += rowBytes;
1428 bot -= rowBytes;
1429 }
1430 // The above loop does nothing on the middle row when height is odd.
1431 if (top == bot && c8888IsValid && dstC8888 != srcC8888) {
1432 uint32_t* mid = reinterpret_cast<uint32_t*>(top);
1433 SkConvertConfig8888Pixels(mid, tightRB, dstC8888, mid, tightRB, srcC8888, width, 1);
1434 }
1435 } else {
1436 // if we aren't flipping Y then we have no reason to be here other than doing
1437 // conversions for 8888 (r/b swap or upm).
1438 GrAssert(c8888IsValid);
1439 uint32_t* b32 = reinterpret_cast<uint32_t*>(buffer);
1440 SkConvertConfig8888Pixels(b32, rowBytes, dstC8888,
1441 b32, rowBytes, srcC8888,
1442 width, height);
1443 }
1444 }
1445 return true;
bsalomon@google.com27847de2011-02-22 20:59:41 +00001446}
1447
bsalomon@google.com75f9f252012-01-31 13:35:56 +00001448void GrContext::resolveRenderTarget(GrRenderTarget* target) {
1449 GrAssert(target);
1450 ASSERT_OWNED_RESOURCE(target);
1451 // In the future we may track whether there are any pending draws to this
1452 // target. We don't today so we always perform a flush. We don't promise
1453 // this to our clients, though.
1454 this->flush();
1455 fGpu->resolveRenderTarget(target);
1456}
1457
senorblanco@chromium.orgef843cd2011-12-02 19:11:17 +00001458void GrContext::copyTexture(GrTexture* src, GrRenderTarget* dst) {
1459 if (NULL == src || NULL == dst) {
1460 return;
1461 }
1462 ASSERT_OWNED_RESOURCE(src);
1463
twiz@google.com1ac87ff2012-04-27 19:39:33 +00001464 // Writes pending to the source texture are not tracked, so a flush
1465 // is required to ensure that the copy captures the most recent contents
1466 // of the source texture. See similar behaviour in
1467 // GrContext::resolveRenderTarget.
1468 this->flush();
1469
bsalomon@google.com873ea0c2012-03-30 15:55:32 +00001470 GrDrawTarget::AutoStateRestore asr(fGpu, GrDrawTarget::kReset_ASRInit);
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +00001471 GrDrawState* drawState = fGpu->drawState();
1472 drawState->setRenderTarget(dst);
senorblanco@chromium.orgef843cd2011-12-02 19:11:17 +00001473 GrMatrix sampleM;
1474 sampleM.setIDiv(src->width(), src->height());
bsalomon@google.com1e266f82011-12-12 16:11:33 +00001475 drawState->sampler(0)->reset(sampleM);
tomhudson@google.com1e8f0162012-07-20 16:25:18 +00001476 drawState->createTextureEffect(0, src);
bsalomon@google.com5db3b6c2012-01-12 20:38:57 +00001477 SkRect rect = SkRect::MakeXYWH(0, 0,
1478 SK_Scalar1 * src->width(),
1479 SK_Scalar1 * src->height());
bsalomon@google.come3d32162012-07-20 13:37:06 +00001480 fGpu->drawSimpleRect(rect, NULL);
senorblanco@chromium.orgef843cd2011-12-02 19:11:17 +00001481}
1482
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001483void GrContext::writeRenderTargetPixels(GrRenderTarget* target,
bsalomon@google.com0342a852012-08-20 19:22:38 +00001484 int left, int top, int width, int height,
1485 GrPixelConfig config,
1486 const void* buffer,
1487 size_t rowBytes,
1488 uint32_t flags) {
bsalomon@google.com6f379512011-11-16 20:36:03 +00001489 SK_TRACE_EVENT0("GrContext::writeRenderTargetPixels");
bsalomon@google.combc4b6542011-11-19 13:56:11 +00001490 ASSERT_OWNED_RESOURCE(target);
bsalomon@google.com6f379512011-11-16 20:36:03 +00001491
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001492 if (NULL == target) {
bsalomon@google.com873ea0c2012-03-30 15:55:32 +00001493 target = fDrawState->getRenderTarget();
bsalomon@google.com6f379512011-11-16 20:36:03 +00001494 if (NULL == target) {
1495 return;
1496 }
1497 }
bsalomon@google.com27847de2011-02-22 20:59:41 +00001498
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001499 // TODO: when underlying api has a direct way to do this we should use it (e.g. glDrawPixels on
1500 // desktop GL).
1501
1502 // We will always call some form of writeTexturePixels and we will pass our flags on to it.
1503 // Thus, we don't perform a flush here since that call will do it (if the kNoFlush flag isn't
1504 // set.)
bsalomon@google.com27847de2011-02-22 20:59:41 +00001505
bsalomon@google.com0342a852012-08-20 19:22:38 +00001506 // If the RT is also a texture and we don't have to premultiply then take the texture path.
1507 // We expect to be at least as fast or faster since it doesn't use an intermediate texture as
1508 // we do below.
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001509
bsalomon@google.coma85449d2011-11-19 02:36:05 +00001510#if !GR_MAC_BUILD
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001511 // At least some drivers on the Mac get confused when glTexImage2D is called on a texture
1512 // attached to an FBO. The FBO still sees the old image. TODO: determine what OS versions and/or
1513 // HW is affected.
bsalomon@google.com0342a852012-08-20 19:22:38 +00001514 if (NULL != target->asTexture() && !(kUnpremul_PixelOpsFlag & flags)) {
1515 this->writeTexturePixels(target->asTexture(),
1516 left, top, width, height,
1517 config, buffer, rowBytes, flags);
bsalomon@google.coma85449d2011-11-19 02:36:05 +00001518 return;
1519 }
1520#endif
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001521 SkAutoTUnref<GrCustomStage> stage;
1522 bool swapRAndB = (fGpu->preferredReadPixelsConfig(config) == GrPixelConfigSwapRAndB(config));
bsalomon@google.coma85449d2011-11-19 02:36:05 +00001523
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001524 GrPixelConfig textureConfig;
bsalomon@google.coma85449d2011-11-19 02:36:05 +00001525 if (swapRAndB) {
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001526 textureConfig = GrPixelConfigSwapRAndB(config);
1527 } else {
1528 textureConfig = config;
bsalomon@google.coma85449d2011-11-19 02:36:05 +00001529 }
1530
robertphillips@google.com75b3c962012-06-07 12:08:45 +00001531 GrTextureDesc desc;
1532 desc.fWidth = width;
1533 desc.fHeight = height;
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001534 desc.fConfig = textureConfig;
bsalomon@google.com50398bf2011-07-26 20:45:30 +00001535 GrAutoScratchTexture ast(this, desc);
1536 GrTexture* texture = ast.texture();
bsalomon@google.com27847de2011-02-22 20:59:41 +00001537 if (NULL == texture) {
1538 return;
1539 }
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001540 // allocate a tmp buffer and sw convert the pixels to premul
1541 SkAutoSTMalloc<128 * 128, uint32_t> tmpPixels(0);
1542
1543 if (kUnpremul_PixelOpsFlag & flags) {
1544 if (kRGBA_8888_GrPixelConfig != config && kBGRA_8888_GrPixelConfig != config) {
1545 return;
1546 }
1547 stage.reset(this->createUPMToPMEffect(texture, swapRAndB));
1548 if (NULL == stage) {
1549 SkCanvas::Config8888 srcConfig8888, dstConfig8888;
1550 GR_DEBUGCODE(bool success = )
1551 grconfig_to_config8888(config, true, &srcConfig8888);
1552 GrAssert(success);
1553 GR_DEBUGCODE(success = )
1554 grconfig_to_config8888(config, false, &dstConfig8888);
1555 GrAssert(success);
1556 const uint32_t* src = reinterpret_cast<const uint32_t*>(buffer);
1557 tmpPixels.reset(width * height);
1558 SkConvertConfig8888Pixels(tmpPixels.get(), 4 * width, dstConfig8888,
1559 src, rowBytes, srcConfig8888,
1560 width, height);
1561 buffer = tmpPixels.get();
1562 rowBytes = 4 * width;
1563 }
1564 }
1565 if (NULL == stage) {
1566 stage.reset(GrConfigConversionEffect::Create(texture, swapRAndB));
1567 GrAssert(NULL != stage);
1568 }
1569
1570 this->writeTexturePixels(texture,
1571 0, 0, width, height,
1572 textureConfig, buffer, rowBytes,
1573 flags & ~kUnpremul_PixelOpsFlag);
bsalomon@google.com27847de2011-02-22 20:59:41 +00001574
bsalomon@google.com873ea0c2012-03-30 15:55:32 +00001575 GrDrawTarget::AutoStateRestore asr(fGpu, GrDrawTarget::kReset_ASRInit);
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +00001576 GrDrawState* drawState = fGpu->drawState();
bsalomon@google.com27847de2011-02-22 20:59:41 +00001577
1578 GrMatrix matrix;
1579 matrix.setTranslate(GrIntToScalar(left), GrIntToScalar(top));
bsalomon@google.com8f9cbd62011-12-09 15:55:34 +00001580 drawState->setViewMatrix(matrix);
1581 drawState->setRenderTarget(target);
bsalomon@google.com27847de2011-02-22 20:59:41 +00001582
bsalomon@google.com5c638652011-07-18 19:31:59 +00001583 matrix.setIDiv(texture->width(), texture->height());
bsalomon@google.comb8670992012-07-25 21:27:09 +00001584 drawState->sampler(0)->reset(matrix);
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001585 drawState->sampler(0)->setCustomStage(stage);
bsalomon@google.com27847de2011-02-22 20:59:41 +00001586
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001587 fGpu->drawSimpleRect(GrRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)), NULL);
bsalomon@google.com27847de2011-02-22 20:59:41 +00001588}
1589////////////////////////////////////////////////////////////////////////////////
1590
bsalomon@google.com07ea2db2012-08-17 14:06:49 +00001591GrDrawTarget* GrContext::prepareToDraw(const GrPaint* paint, BufferedDraw buffered) {
bsalomon@google.com1d4edd32012-08-16 18:36:06 +00001592 if (kNo_BufferedDraw == buffered && kYes_BufferedDraw == fLastDrawWasBuffered) {
bsalomon@google.comfb4ce6f2012-03-14 13:27:54 +00001593 this->flushDrawBuffer();
bsalomon@google.com1d4edd32012-08-16 18:36:06 +00001594 fLastDrawWasBuffered = kNo_BufferedDraw;
bsalomon@google.com27847de2011-02-22 20:59:41 +00001595 }
bsalomon@google.com07ea2db2012-08-17 14:06:49 +00001596 if (NULL != paint) {
bsalomon@google.comaf84e742012-10-05 13:23:24 +00001597 GrAssert(fDrawState->stagesDisabled());
1598 fDrawState->setFromPaint(*paint);
1599#if GR_DEBUG_PARTIAL_COVERAGE_CHECK
1600 if ((paint->hasMask() || 0xff != paint->fCoverage) &&
1601 !fGpu->canApplyCoverage()) {
1602 GrPrintf("Partial pixel coverage will be incorrectly blended.\n");
1603 }
1604#endif
bsalomon@google.com07ea2db2012-08-17 14:06:49 +00001605 }
bsalomon@google.com1d4edd32012-08-16 18:36:06 +00001606 if (kYes_BufferedDraw == buffered) {
1607 fDrawBuffer->setClip(fGpu->getClip());
1608 fLastDrawWasBuffered = kYes_BufferedDraw;
1609 return fDrawBuffer;
1610 } else {
1611 GrAssert(kNo_BufferedDraw == buffered);
1612 return fGpu;
bsalomon@google.com27847de2011-02-22 20:59:41 +00001613 }
bsalomon@google.com27847de2011-02-22 20:59:41 +00001614}
1615
robertphillips@google.com72176b22012-05-23 13:19:12 +00001616/*
1617 * This method finds a path renderer that can draw the specified path on
1618 * the provided target.
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001619 * Due to its expense, the software path renderer has split out so it can
robertphillips@google.com72176b22012-05-23 13:19:12 +00001620 * can be individually allowed/disallowed via the "allowSW" boolean.
1621 */
bsalomon@google.com8d033a12012-04-27 15:52:53 +00001622GrPathRenderer* GrContext::getPathRenderer(const SkPath& path,
bsalomon@google.com289533a2011-10-27 12:34:25 +00001623 GrPathFill fill,
bsalomon@google.comc2099d22012-03-02 21:26:50 +00001624 const GrDrawTarget* target,
robertphillips@google.com72176b22012-05-23 13:19:12 +00001625 bool antiAlias,
1626 bool allowSW) {
bsalomon@google.com30085192011-08-19 15:42:31 +00001627 if (NULL == fPathRendererChain) {
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001628 fPathRendererChain =
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001629 SkNEW_ARGS(GrPathRendererChain,
1630 (this, GrPathRendererChain::kNone_UsageFlag));
bsalomon@google.com30085192011-08-19 15:42:31 +00001631 }
robertphillips@google.com72176b22012-05-23 13:19:12 +00001632
1633 GrPathRenderer* pr = fPathRendererChain->getPathRenderer(path, fill,
1634 target,
1635 antiAlias);
1636
1637 if (NULL == pr && allowSW) {
1638 if (NULL == fSoftwarePathRenderer) {
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001639 fSoftwarePathRenderer = SkNEW_ARGS(GrSoftwarePathRenderer, (this));
robertphillips@google.com72176b22012-05-23 13:19:12 +00001640 }
1641
1642 pr = fSoftwarePathRenderer;
1643 }
1644
1645 return pr;
bsalomon@google.com30085192011-08-19 15:42:31 +00001646}
1647
bsalomon@google.com27847de2011-02-22 20:59:41 +00001648////////////////////////////////////////////////////////////////////////////////
1649
bsalomon@google.com27847de2011-02-22 20:59:41 +00001650void GrContext::setRenderTarget(GrRenderTarget* target) {
bsalomon@google.combc4b6542011-11-19 13:56:11 +00001651 ASSERT_OWNED_RESOURCE(target);
bsalomon@google.com07ea2db2012-08-17 14:06:49 +00001652 fDrawState->setRenderTarget(target);
bsalomon@google.com27847de2011-02-22 20:59:41 +00001653}
1654
1655GrRenderTarget* GrContext::getRenderTarget() {
bsalomon@google.com10e04bf2012-03-30 14:35:04 +00001656 return fDrawState->getRenderTarget();
bsalomon@google.com27847de2011-02-22 20:59:41 +00001657}
1658
1659const GrRenderTarget* GrContext::getRenderTarget() const {
bsalomon@google.com10e04bf2012-03-30 14:35:04 +00001660 return fDrawState->getRenderTarget();
bsalomon@google.com27847de2011-02-22 20:59:41 +00001661}
1662
robertphillips@google.com99a5ac02012-04-10 19:26:38 +00001663bool GrContext::isConfigRenderable(GrPixelConfig config) const {
1664 return fGpu->isConfigRenderable(config);
1665}
1666
bsalomon@google.com27847de2011-02-22 20:59:41 +00001667const GrMatrix& GrContext::getMatrix() const {
bsalomon@google.com10e04bf2012-03-30 14:35:04 +00001668 return fDrawState->getViewMatrix();
bsalomon@google.com27847de2011-02-22 20:59:41 +00001669}
1670
1671void GrContext::setMatrix(const GrMatrix& m) {
bsalomon@google.com10e04bf2012-03-30 14:35:04 +00001672 fDrawState->setViewMatrix(m);
bsalomon@google.com27847de2011-02-22 20:59:41 +00001673}
1674
1675void GrContext::concatMatrix(const GrMatrix& m) const {
bsalomon@google.com10e04bf2012-03-30 14:35:04 +00001676 fDrawState->preConcatViewMatrix(m);
bsalomon@google.com27847de2011-02-22 20:59:41 +00001677}
1678
1679static inline intptr_t setOrClear(intptr_t bits, int shift, intptr_t pred) {
1680 intptr_t mask = 1 << shift;
1681 if (pred) {
1682 bits |= mask;
1683 } else {
1684 bits &= ~mask;
1685 }
1686 return bits;
1687}
1688
bsalomon@google.com583a1e32011-08-17 13:42:46 +00001689GrContext::GrContext(GrGpu* gpu) {
bsalomon@google.comc0af3172012-06-15 14:10:09 +00001690 ++THREAD_INSTANCE_COUNT;
1691
bsalomon@google.com27847de2011-02-22 20:59:41 +00001692 fGpu = gpu;
1693 fGpu->ref();
bsalomon@google.com669fdc42011-04-05 17:08:27 +00001694 fGpu->setContext(this);
bsalomon@google.com8fe72472011-03-30 21:26:44 +00001695
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001696 fDrawState = SkNEW(GrDrawState);
bsalomon@google.com10e04bf2012-03-30 14:35:04 +00001697 fGpu->setDrawState(fDrawState);
1698
bsalomon@google.com30085192011-08-19 15:42:31 +00001699 fPathRendererChain = NULL;
robertphillips@google.com72176b22012-05-23 13:19:12 +00001700 fSoftwarePathRenderer = NULL;
bsalomon@google.comdfe75bc2011-03-25 12:31:16 +00001701
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001702 fTextureCache = SkNEW_ARGS(GrResourceCache,
1703 (MAX_TEXTURE_CACHE_COUNT,
1704 MAX_TEXTURE_CACHE_BYTES));
1705 fFontCache = SkNEW_ARGS(GrFontCache, (fGpu));
bsalomon@google.com27847de2011-02-22 20:59:41 +00001706
bsalomon@google.com1d4edd32012-08-16 18:36:06 +00001707 fLastDrawWasBuffered = kNo_BufferedDraw;
bsalomon@google.com27847de2011-02-22 20:59:41 +00001708
bsalomon@google.com8fe72472011-03-30 21:26:44 +00001709 fDrawBuffer = NULL;
1710 fDrawBufferVBAllocPool = NULL;
1711 fDrawBufferIBAllocPool = NULL;
1712
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001713 fAARectRenderer = SkNEW(GrAARectRenderer);
bsalomon@google.com10e04bf2012-03-30 14:35:04 +00001714
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001715 fDidTestPMConversions = false;
1716
bsalomon@google.com8fe72472011-03-30 21:26:44 +00001717 this->setupDrawBuffer();
1718}
1719
1720void GrContext::setupDrawBuffer() {
1721
1722 GrAssert(NULL == fDrawBuffer);
1723 GrAssert(NULL == fDrawBufferVBAllocPool);
1724 GrAssert(NULL == fDrawBufferIBAllocPool);
1725
bsalomon@google.comde6ac2d2011-02-25 21:50:42 +00001726 fDrawBufferVBAllocPool =
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001727 SkNEW_ARGS(GrVertexBufferAllocPool, (fGpu, false,
bsalomon@google.com27847de2011-02-22 20:59:41 +00001728 DRAW_BUFFER_VBPOOL_BUFFER_SIZE,
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001729 DRAW_BUFFER_VBPOOL_PREALLOC_BUFFERS));
bsalomon@google.comde6ac2d2011-02-25 21:50:42 +00001730 fDrawBufferIBAllocPool =
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001731 SkNEW_ARGS(GrIndexBufferAllocPool, (fGpu, false,
bsalomon@google.comde6ac2d2011-02-25 21:50:42 +00001732 DRAW_BUFFER_IBPOOL_BUFFER_SIZE,
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001733 DRAW_BUFFER_IBPOOL_PREALLOC_BUFFERS));
bsalomon@google.com27847de2011-02-22 20:59:41 +00001734
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001735 fDrawBuffer = SkNEW_ARGS(GrInOrderDrawBuffer, (fGpu,
bsalomon@google.com471d4712011-08-23 15:45:25 +00001736 fDrawBufferVBAllocPool,
tomhudson@google.comc377baf2012-07-09 20:17:56 +00001737 fDrawBufferIBAllocPool));
bsalomon@google.com3c4d0322012-04-03 18:04:51 +00001738
bsalomon@google.com27847de2011-02-22 20:59:41 +00001739 fDrawBuffer->setQuadIndexBuffer(this->getQuadIndexBuffer());
bsalomon@google.com1015e032012-06-25 18:41:04 +00001740 if (fDrawBuffer) {
1741 fDrawBuffer->setAutoFlushTarget(fGpu);
1742 fDrawBuffer->setDrawState(fDrawState);
1743 }
bsalomon@google.com27847de2011-02-22 20:59:41 +00001744}
1745
bsalomon@google.com27847de2011-02-22 20:59:41 +00001746GrDrawTarget* GrContext::getTextTarget(const GrPaint& paint) {
bsalomon@google.com07ea2db2012-08-17 14:06:49 +00001747 return prepareToDraw(&paint, DEFAULT_BUFFERING);
bsalomon@google.com27847de2011-02-22 20:59:41 +00001748}
1749
1750const GrIndexBuffer* GrContext::getQuadIndexBuffer() const {
1751 return fGpu->getQuadIndexBuffer();
1752}
bsalomon@google.comdfe75bc2011-03-25 12:31:16 +00001753
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001754namespace {
1755void test_pm_conversions(GrContext* ctx, int* pmToUPMValue, int* upmToPMValue) {
1756 GrConfigConversionEffect::PMConversion pmToUPM;
1757 GrConfigConversionEffect::PMConversion upmToPM;
1758 GrConfigConversionEffect::TestForPreservingPMConversions(ctx, &pmToUPM, &upmToPM);
1759 *pmToUPMValue = pmToUPM;
1760 *upmToPMValue = upmToPM;
1761}
1762}
1763
1764GrCustomStage* GrContext::createPMToUPMEffect(GrTexture* texture, bool swapRAndB) {
1765 if (!fDidTestPMConversions) {
1766 test_pm_conversions(this, &fPMToUPMConversion, &fUPMToPMConversion);
bsalomon@google.comd0f3f682012-08-28 13:08:14 +00001767 fDidTestPMConversions = true;
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001768 }
1769 GrConfigConversionEffect::PMConversion pmToUPM =
1770 static_cast<GrConfigConversionEffect::PMConversion>(fPMToUPMConversion);
1771 if (GrConfigConversionEffect::kNone_PMConversion != pmToUPM) {
1772 return GrConfigConversionEffect::Create(texture, swapRAndB, pmToUPM);
1773 } else {
1774 return NULL;
1775 }
1776}
1777
1778GrCustomStage* GrContext::createUPMToPMEffect(GrTexture* texture, bool swapRAndB) {
1779 if (!fDidTestPMConversions) {
1780 test_pm_conversions(this, &fPMToUPMConversion, &fUPMToPMConversion);
bsalomon@google.comd0f3f682012-08-28 13:08:14 +00001781 fDidTestPMConversions = true;
bsalomon@google.coma04e8e82012-08-27 12:53:13 +00001782 }
1783 GrConfigConversionEffect::PMConversion upmToPM =
1784 static_cast<GrConfigConversionEffect::PMConversion>(fUPMToPMConversion);
1785 if (GrConfigConversionEffect::kNone_PMConversion != upmToPM) {
1786 return GrConfigConversionEffect::Create(texture, swapRAndB, upmToPM);
1787 } else {
1788 return NULL;
1789 }
1790}
1791
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001792GrTexture* GrContext::gaussianBlur(GrTexture* srcTexture,
senorblanco@chromium.org1e95d712012-07-18 19:52:53 +00001793 bool canClobberSrc,
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001794 const SkRect& rect,
1795 float sigmaX, float sigmaY) {
senorblanco@chromium.orgceb44142012-03-05 20:53:36 +00001796 ASSERT_OWNED_RESOURCE(srcTexture);
robertphillips@google.comccb39502012-10-01 18:25:13 +00001797
1798 AutoRenderTarget art(this);
1799
robertphillips@google.comfea85ac2012-07-11 18:53:23 +00001800 AutoMatrix avm(this, GrMatrix::I());
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001801 SkIRect clearRect;
bsalomon@google.comb505a122012-05-31 18:40:36 +00001802 int scaleFactorX, radiusX;
1803 int scaleFactorY, radiusY;
1804 sigmaX = adjust_sigma(sigmaX, &scaleFactorX, &radiusX);
1805 sigmaY = adjust_sigma(sigmaY, &scaleFactorY, &radiusY);
bsalomon@google.combc4b6542011-11-19 13:56:11 +00001806
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001807 SkRect srcRect(rect);
1808 scale_rect(&srcRect, 1.0f / scaleFactorX, 1.0f / scaleFactorY);
1809 srcRect.roundOut();
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001810 scale_rect(&srcRect, static_cast<float>(scaleFactorX),
robertphillips@google.com8637a362012-04-10 18:32:35 +00001811 static_cast<float>(scaleFactorY));
robertphillips@google.com3e11c0b2012-07-11 18:20:35 +00001812
robertphillips@google.com56c79b12012-07-11 20:57:46 +00001813 AutoClip acs(this, srcRect);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001814
bsalomon@google.com0342a852012-08-20 19:22:38 +00001815 GrAssert(kBGRA_8888_GrPixelConfig == srcTexture->config() ||
1816 kRGBA_8888_GrPixelConfig == srcTexture->config() ||
robertphillips@google.com99a5ac02012-04-10 19:26:38 +00001817 kAlpha_8_GrPixelConfig == srcTexture->config());
1818
robertphillips@google.com75b3c962012-06-07 12:08:45 +00001819 GrTextureDesc desc;
1820 desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
1821 desc.fWidth = SkScalarFloorToInt(srcRect.width());
1822 desc.fHeight = SkScalarFloorToInt(srcRect.height());
1823 desc.fConfig = srcTexture->config();
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001824
senorblanco@chromium.org1e95d712012-07-18 19:52:53 +00001825 GrAutoScratchTexture temp1, temp2;
1826 GrTexture* dstTexture = temp1.set(this, desc);
1827 GrTexture* tempTexture = canClobberSrc ? srcTexture : temp2.set(this, desc);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001828
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001829 GrPaint paint;
1830 paint.reset();
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001831
1832 for (int i = 1; i < scaleFactorX || i < scaleFactorY; i *= 2) {
bsalomon@google.com88becf42012-10-05 14:54:42 +00001833 paint.colorSampler(0)->matrix()->setIDiv(srcTexture->width(),
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001834 srcTexture->height());
1835 this->setRenderTarget(dstTexture->asRenderTarget());
1836 SkRect dstRect(srcRect);
1837 scale_rect(&dstRect, i < scaleFactorX ? 0.5f : 1.0f,
1838 i < scaleFactorY ? 0.5f : 1.0f);
bsalomon@google.com88becf42012-10-05 14:54:42 +00001839 paint.colorSampler(0)->setCustomStage(SkNEW_ARGS(GrSingleTextureEffect,
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001840 (srcTexture, true)))->unref();
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001841 this->drawRectToRect(paint, dstRect, srcRect);
1842 srcRect = dstRect;
senorblanco@chromium.org1e95d712012-07-18 19:52:53 +00001843 srcTexture = dstTexture;
1844 SkTSwap(dstTexture, tempTexture);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001845 }
1846
robertphillips@google.com7a396332012-05-10 15:11:27 +00001847 SkIRect srcIRect;
1848 srcRect.roundOut(&srcIRect);
1849
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001850 if (sigmaX > 0.0f) {
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001851 if (scaleFactorX > 1) {
bsalomon@google.comb505a122012-05-31 18:40:36 +00001852 // Clear out a radius to the right of the srcRect to prevent the
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001853 // X convolution from reading garbage.
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001854 clearRect = SkIRect::MakeXYWH(srcIRect.fRight, srcIRect.fTop,
bsalomon@google.comb505a122012-05-31 18:40:36 +00001855 radiusX, srcIRect.height());
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001856 this->clear(&clearRect, 0x0);
1857 }
1858
1859 this->setRenderTarget(dstTexture->asRenderTarget());
bsalomon@google.com07ea2db2012-08-17 14:06:49 +00001860 GrDrawTarget* target = this->prepareToDraw(NULL, DEFAULT_BUFFERING);
1861 convolve_gaussian(target, srcTexture, srcRect, sigmaX, radiusX,
bsalomon@google.comb505a122012-05-31 18:40:36 +00001862 Gr1DKernelEffect::kX_Direction);
senorblanco@chromium.org1e95d712012-07-18 19:52:53 +00001863 srcTexture = dstTexture;
1864 SkTSwap(dstTexture, tempTexture);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001865 }
1866
1867 if (sigmaY > 0.0f) {
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001868 if (scaleFactorY > 1 || sigmaX > 0.0f) {
bsalomon@google.comb505a122012-05-31 18:40:36 +00001869 // Clear out a radius below the srcRect to prevent the Y
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001870 // convolution from reading garbage.
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001871 clearRect = SkIRect::MakeXYWH(srcIRect.fLeft, srcIRect.fBottom,
bsalomon@google.comb505a122012-05-31 18:40:36 +00001872 srcIRect.width(), radiusY);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001873 this->clear(&clearRect, 0x0);
1874 }
1875
1876 this->setRenderTarget(dstTexture->asRenderTarget());
bsalomon@google.com07ea2db2012-08-17 14:06:49 +00001877 GrDrawTarget* target = this->prepareToDraw(NULL, DEFAULT_BUFFERING);
1878 convolve_gaussian(target, srcTexture, srcRect, sigmaY, radiusY,
bsalomon@google.comb505a122012-05-31 18:40:36 +00001879 Gr1DKernelEffect::kY_Direction);
senorblanco@chromium.org1e95d712012-07-18 19:52:53 +00001880 srcTexture = dstTexture;
1881 SkTSwap(dstTexture, tempTexture);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001882 }
1883
1884 if (scaleFactorX > 1 || scaleFactorY > 1) {
1885 // Clear one pixel to the right and below, to accommodate bilinear
1886 // upsampling.
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001887 clearRect = SkIRect::MakeXYWH(srcIRect.fLeft, srcIRect.fBottom,
robertphillips@google.com7a396332012-05-10 15:11:27 +00001888 srcIRect.width() + 1, 1);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001889 this->clear(&clearRect, 0x0);
rmistry@google.comfbfcd562012-08-23 18:09:54 +00001890 clearRect = SkIRect::MakeXYWH(srcIRect.fRight, srcIRect.fTop,
robertphillips@google.com7a396332012-05-10 15:11:27 +00001891 1, srcIRect.height());
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001892 this->clear(&clearRect, 0x0);
1893 // FIXME: This should be mitchell, not bilinear.
bsalomon@google.com88becf42012-10-05 14:54:42 +00001894 paint.colorSampler(0)->matrix()->setIDiv(srcTexture->width(),
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001895 srcTexture->height());
1896 this->setRenderTarget(dstTexture->asRenderTarget());
bsalomon@google.com88becf42012-10-05 14:54:42 +00001897 paint.colorSampler(0)->setCustomStage(SkNEW_ARGS(GrSingleTextureEffect,
bsalomon@google.com1ce49fc2012-09-18 14:14:49 +00001898 (srcTexture, true)))->unref();
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001899 SkRect dstRect(srcRect);
robertphillips@google.com7a396332012-05-10 15:11:27 +00001900 scale_rect(&dstRect, (float) scaleFactorX, (float) scaleFactorY);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001901 this->drawRectToRect(paint, dstRect, srcRect);
1902 srcRect = dstRect;
senorblanco@chromium.org1e95d712012-07-18 19:52:53 +00001903 srcTexture = dstTexture;
1904 SkTSwap(dstTexture, tempTexture);
senorblanco@chromium.org3b4dd902012-03-05 20:41:22 +00001905 }
senorblanco@chromium.org1e95d712012-07-18 19:52:53 +00001906 if (srcTexture == temp1.texture()) {
1907 return temp1.detach();
1908 } else if (srcTexture == temp2.texture()) {
1909 return temp2.detach();
1910 } else {
1911 srcTexture->ref();
1912 return srcTexture;
1913 }
senorblanco@chromium.org05054f12012-03-02 21:05:45 +00001914}
bsalomon@google.com1e266f82011-12-12 16:11:33 +00001915
bsalomon@google.comc4364992011-11-07 15:54:49 +00001916///////////////////////////////////////////////////////////////////////////////
robertphillips@google.com59552022012-08-31 13:07:37 +00001917#if GR_CACHE_STATS
robertphillips@google.com5f9f2f52012-08-22 10:57:05 +00001918void GrContext::printCacheStats() const {
1919 fTextureCache->printStats();
1920}
1921#endif