reorg iteration code in rrects GM, tightly pack rrects drawn in _effect version.

gm/rrects.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 #if SK_SUPPORT_GPU
 #include "GrTest.h"
@@ skipping 47 matching lines @@
 
     virtual uint32_t onGetFlags() const SK_OVERRIDE {
         if (kEffect_Type == fType) {
             return kGPUOnly_Flag;
         } else {
             return 0;
         }
     }
 
     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
-        int numRRects = kNumRRects;
 #if SK_SUPPORT_GPU
         SkBaseDevice* device = canvas->getTopDevice();
         GrContext* context = NULL;
         GrRenderTarget* rt = device->accessRenderTarget();
         if (NULL != rt) {
             context = rt->getContext();
         }
         if (kEffect_Type == fType && NULL == context) {
             return;
         }
-        if (kEffect_Type == fType) {
-            numRRects *= kGrEffectEdgeTypeCnt;
-        }
 #endif
 
         SkPaint paint;
         if (kAA_Draw_Type == fType) {
             paint.setAntiAlias(true);
         }
 
-        static const SkRect kMaxTileBound = SkRect::MakeWH(SkIntToScalar(kTileX), SkIntToScalar(kTileY));
+        static const SkRect kMaxTileBound = SkRect::MakeWH(SkIntToScalar(kTileX),
+                                                           SkIntToScalar(kTileY));
+#ifdef SK_DEBUG
+        static const SkRect kMaxImageBound = SkRect::MakeWH(SkIntToScalar(kImageWidth),
+                                                            SkIntToScalar(kImageHeight));
+#endif
 
-        int curRRect = 0;
-        for (int y = 1; y < kImageHeight; y += kTileY) {
-            for (int x = 1; x < kImageWidth; x += kTileX) {
-                if (curRRect >= numRRects) {
-                    break;
-                }
-                int rrectIdx = curRRect % kNumRRects;
-                SkASSERT(kMaxTileBound.contains(fRRects[rrectIdx].getBounds()));
+        int lastEdgeType = (kEffect_Type == fType) ? kLast_GrEffectEdgeType: 0;
 
+        int y = 1;
+        for (int et = (GrEffectEdgeType) 0; et <= lastEdgeType; ++et) {
+            int x = 1;
+            for (int curRRect = 0; curRRect < kNumRRects; ++curRRect) {
+                bool drew = true;
+#ifdef SK_DEBUG
+                SkASSERT(kMaxTileBound.contains(fRRects[curRRect].getBounds()));
+                SkRect imageSpaceBounds = fRRects[curRRect].getBounds();
+                imageSpaceBounds.offset(SkIntToScalar(x), SkIntToScalar(y));
+                SkASSERT(kMaxImageBound.contains(imageSpaceBounds));
+#endif
                 canvas->save();
                     canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
                     if (kEffect_Type == fType) {
 #if SK_SUPPORT_GPU
                         GrTestTarget tt;
                         context->getTestTarget(&tt);
                         if (NULL == tt.target()) {
                             SkDEBUGFAIL("Couldn't get Gr test target.");
                             return;
                         }
                         GrDrawState* drawState = tt.target()->drawState();
 
-                        SkRRect rrect = fRRects[rrectIdx];
+                        SkRRect rrect = fRRects[curRRect];
                         rrect.offset(SkIntToScalar(x), SkIntToScalar(y));
-                        GrEffectEdgeType edgeType = (GrEffectEdgeType) (curRRect / kNumRRects);
+                        GrEffectEdgeType edgeType = (GrEffectEdgeType) et;
                         SkAutoTUnref<GrEffectRef> effect(GrRRectEffect::Create(edgeType, rrect));
                         if (effect) {
                             drawState->addCoverageEffect(effect);
                             drawState->setIdentityViewMatrix();
                             drawState->setRenderTarget(rt);
                             drawState->setColor(0xff000000);
 
                             SkRect bounds = rrect.getBounds();
                             bounds.outset(2.f, 2.f);
 
                             tt.target()->drawSimpleRect(bounds);
+                        } else {
+                            drew = false;
                         }
 #endif
                     } else if (kBW_Clip_Type == fType || kAA_Clip_Type == fType) {
                         bool aaClip = (kAA_Clip_Type == fType);
-                        canvas->clipRRect(fRRects[rrectIdx], SkRegion::kReplace_Op, aaClip);
+                        canvas->clipRRect(fRRects[curRRect], SkRegion::kReplace_Op, aaClip);
                         canvas->drawRect(kMaxTileBound, paint);
                     } else {
-                        canvas->drawRRect(fRRects[rrectIdx], paint);
+                        canvas->drawRRect(fRRects[curRRect], paint);
                     }
-                    ++curRRect;
                 canvas->restore();
+                if (drew) {
+                    x = x + kTileX;
+                    if (x > kImageWidth) {
+                        x = 1;
+                        y += kTileY;
+                    }
+                }
+            }
+            if (x != 1) {
+                y += kTileY;
             }
         }
     }
 
     void setUpRRects() {
         // each RRect must fit in a 0x0 -> (kTileX-2)x(kTileY-2) block. These will be tiled across
         // the screen in kTileX x kTileY tiles. The extra empty pixels on each side are for AA.
 
         // simple cases
         fRRects[0].setRect(SkRect::MakeWH(kTileX-2, kTileY-2));
@@ skipping 77 matching lines @@
 
 DEF_GM( return new RRectGM(RRectGM::kAA_Draw_Type); )
 DEF_GM( return new RRectGM(RRectGM::kBW_Draw_Type); )
 DEF_GM( return new RRectGM(RRectGM::kAA_Clip_Type); )
 DEF_GM( return new RRectGM(RRectGM::kBW_Clip_Type); )
 #if SK_SUPPORT_GPU
 DEF_GM( return new RRectGM(RRectGM::kEffect_Type); )
 #endif
 
 }