Render batch bounds as stroke rects

tools/debugger/SkDebugCanvas.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 "SkCanvasPriv.h"
 #include "SkClipStack.h"
 #include "SkDebugCanvas.h"
 #include "SkDrawCommand.h"
 #include "SkDevice.h"
 #include "SkPaintFilterCanvas.h"
 #include "SkOverdrawMode.h"
 
+#if SK_SUPPORT_GPU
+#include "GrAuditTrail.h"
+#include "GrContext.h"
+#include "GrRenderTarget.h"
+#endif
+
 #define SKDEBUGCANVAS_VERSION            1
 #define SKDEBUGCANVAS_ATTRIBUTE_VERSION  "version"
 #define SKDEBUGCANVAS_ATTRIBUTE_COMMANDS "commands"
 
 class DebugPaintFilterCanvas : public SkPaintFilterCanvas {
 public:
     DebugPaintFilterCanvas(int width,
                            int height,
                            bool overdrawViz,
                            bool overrideFilterQuality,
@@ skipping 35 matching lines @@
 };
 
 SkDebugCanvas::SkDebugCanvas(int width, int height)
         : INHERITED(width, height)
         , fPicture(nullptr)
         , fFilter(false)
         , fMegaVizMode(false)
         , fOverdrawViz(false)
         , fOverrideFilterQuality(false)
         , fFilterQuality(kNone_SkFilterQuality)
-        , fClipVizColor(SK_ColorTRANSPARENT) {
+        , fClipVizColor(SK_ColorTRANSPARENT)
+        , fDrawGpuBatchBounds(true) {
     fUserMatrix.reset();
 
     // SkPicturePlayback uses the base-class' quickReject calls to cull clipped
     // operations. This can lead to problems in the debugger which expects all
     // the operations in the captured skp to appear in the debug canvas. To
     // circumvent this we create a wide open clip here (an empty clip rect
     // is not sufficient).
     // Internally, the SkRect passed to clipRect is converted to an SkIRect and
     // rounded out. The following code creates a nearly maximal rect that will
     // not get collapsed by the coming conversions (Due to precision loss the
@@ skipping 120 matching lines @@
     canvas->clear(SK_ColorWHITE);
     canvas->resetMatrix();
     if (!windowRect.isEmpty()) {
         canvas->clipRect(windowRect, SkRegion::kReplace_Op);
     }
     this->applyUserTransform(canvas);
 
     if (fPaintFilterCanvas) {
         fPaintFilterCanvas->addCanvas(canvas);
         canvas = fPaintFilterCanvas.get();
+    
     }
 
     if (fMegaVizMode) {
         this->markActiveCommands(index);
     }
+   
+    // If we have a GPU backend we can also visualize the batching information
+#if SK_SUPPORT_GPU
+    GrAuditTrail* at = nullptr;
+    GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
+    if (rt && fDrawGpuBatchBounds) {
+        GrContext* ctx = rt->getContext();
+        if (ctx) {
+            at = ctx->getAuditTrail();
+        }
+    }
+#endif
 
     for (int i = 0; i <= index; i++) {
         if (i == index && fFilter) {
             canvas->clear(0xAAFFFFFF);
         }
+   
+#if SK_SUPPORT_GPU
+        GrAuditTrail::AutoCollectBatches* acb = nullptr;
+        if (at) {
+            acb = new GrAuditTrail::AutoCollectBatches(at, i);
+        }
+#endif
 
         if (fCommandVector[i]->isVisible()) {
             if (fMegaVizMode && fCommandVector[i]->active()) {
                 // "active" commands execute their visualization behaviors:
                 //     All active saveLayers get replaced with saves so all draws go to the
                 //     visible canvas.
                 //     All active culls draw their cull box
                 fCommandVector[i]->vizExecute(canvas);
             } else {
                 fCommandVector[i]->setUserMatrix(fUserMatrix);
                 fCommandVector[i]->execute(canvas);
             }
         }
+#if SK_SUPPORT_GPU
+        if (at && acb) {
+            delete acb;
+        }
+#endif
     }
 
     if (SkColorGetA(fClipVizColor) != 0) {
         canvas->save();
         #define LARGE_COORD 1000000000
         canvas->clipRect(SkRect::MakeLTRB(-LARGE_COORD, -LARGE_COORD, LARGE_COORD, LARGE_COORD),
                        SkRegion::kReverseDifference_Op);
         SkPaint clipPaint;
         clipPaint.setColor(fClipVizColor);
         canvas->drawPaint(clipPaint);
@@ skipping 42 matching lines @@
     fMatrix = canvas->getTotalMatrix();
     if (!canvas->getClipDeviceBounds(&fClip)) {
         fClip.setEmpty();
     }
 
     canvas->restoreToCount(saveCount);
 
     if (fPaintFilterCanvas) {
         fPaintFilterCanvas->removeAll();
     }
+
+#if SK_SUPPORT_GPU
+    // draw any batches if required and issue a full reset onto GrAuditTrail
+    if (at) {
+        GrAuditTrail::AutoEnable ae(at);
+        SkTArray<GrAuditTrail::BatchInfo> childrenBounds;
+        at->getBoundsByClientID(&childrenBounds, index);
+        SkPaint paint;
+        paint.setStyle(SkPaint::kStroke_Style);
+        paint.setStrokeWidth(1);
+        for (int i = 0; i < childrenBounds.count(); i++) {
+            paint.setColor(SK_ColorBLACK);
+            canvas->drawRect(childrenBounds[i].fBounds, paint);
+            for (int j = 0; j < childrenBounds[i].fBatches.count(); j++) {
+                const GrAuditTrail::BatchInfo::Batch& batch = childrenBounds[i].fBatches[j];
+                if (batch.fClientID != index) {
+                    paint.setColor(SK_ColorBLUE);
+                } else {
+                    paint.setColor(SK_ColorRED);
+                }
+                canvas->drawRect(batch.fBounds, paint);
+            }
+        }
+
+        at->fullReset();
+    }
+    
+#endif
 }
 
 void SkDebugCanvas::deleteDrawCommandAt(int index) {
     SkASSERT(index < fCommandVector.count());
     delete fCommandVector[index];
     fCommandVector.remove(index);
 }
 
 SkDrawCommand* SkDebugCanvas::getDrawCommandAt(int index) {
     SkASSERT(index < fCommandVector.count());
@@ skipping 338 matching lines @@
 }
 
 bool SkDebugCanvas::lastClipStackData(const SkPath& devPath) {
     if (fCalledAddStackData) {
         fClipStackData.appendf("<br>");
         addPathData(devPath, "pathOut");
         return true;
     }
     return false;
 }