Add texture filtering override to debugger

src/utils/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 "SkColorPriv.h"
 #include "SkDebugCanvas.h"
 #include "SkDrawCommand.h"
 #include "SkDrawFilter.h"
 #include "SkDevice.h"
 #include "SkXfermode.h"
 
 static SkBitmap make_noconfig_bm(int width, int height) {
     SkBitmap bm;
     bm.setConfig(SkBitmap::kNo_Config, width, height);
     return bm;
 }
 
 SkDebugCanvas::SkDebugCanvas(int width, int height)
         : INHERITED(make_noconfig_bm(width, height))
         , fOverdrawViz(false)
         , fOverdrawFilter(NULL)
+        , fOverrideTexFiltering(false)
+        , fTexOverrideFilter(NULL)
         , fOutstandingSaveCount(0) {
     // TODO(chudy): Free up memory from all draw commands in destructor.
     fWidth = width;
     fHeight = height;
     // do we need fBm anywhere?
     fBm.setConfig(SkBitmap::kNo_Config, fWidth, fHeight);
     fFilter = false;
     fIndex = 0;
     fUserMatrix.reset();
 }
@@ skipping 65 matching lines @@
         if (gTable[i] == dst) {
             return gTable[i+1];
         }
     }
 
     return gTable[SK_ARRAY_COUNT(gTable)-1];
 }
 
 // The OverdrawFilter modifies every paint to use an SkProcXfermode which
 // in turn invokes OverdrawXferModeProc
-class OverdrawFilter : public SkDrawFilter {
+class SkOverdrawFilter : public SkDrawFilter {
 public:
-    OverdrawFilter() {
+    SkOverdrawFilter() {
         fXferMode = new SkProcXfermode(OverdrawXferModeProc);
     }
 
-    virtual ~OverdrawFilter() {
+    virtual ~SkOverdrawFilter() {
         delete fXferMode;
     }
 
     virtual bool filter(SkPaint* p, Type) SK_OVERRIDE {
         p->setXfermode(fXferMode);
         return true;
     }
 
 protected:
     SkXfermode* fXferMode;
 
 private:
     typedef SkDrawFilter INHERITED;
 };
 
+// SkTexOverrideFilter modifies every paint to use the specified 
+// texture filtering mode
+class SkTexOverrideFilter : public SkDrawFilter {
+public:
+    SkTexOverrideFilter() : fFilterLevel(SkPaint::kNone_FilterLevel) {
+    }
+
+    void setFilterLevel(SkPaint::FilterLevel filterLevel) {
+        fFilterLevel = filterLevel;
+    }
+
+    virtual bool filter(SkPaint* p, Type) SK_OVERRIDE {
+        p->setFilterLevel(fFilterLevel);
+        return true;
+    }
+
+protected:
+    SkPaint::FilterLevel fFilterLevel;
+
+private:
+    typedef SkDrawFilter INHERITED;
+};
+
 void SkDebugCanvas::drawTo(SkCanvas* canvas, int index) {
     SkASSERT(!fCommandVector.isEmpty());
     SkASSERT(index < fCommandVector.count());
     int i;
 
     // This only works assuming the canvas and device are the same ones that
     // were previously drawn into because they need to preserve all saves
     // and restores.
     if (fIndex < index) {
         i = fIndex + 1;
@@ skipping 10 matching lines @@
         applyUserTransform(canvas);
         fOutstandingSaveCount = 0;
     }
 
     // The setting of the draw filter has to go here (rather than in
     // SkRasterWidget) due to the canvas restores this class performs.
     // Since the draw filter is stored in the layer stack if we
     // call setDrawFilter on anything but the root layer odd things happen.
     if (fOverdrawViz) {
         if (NULL == fOverdrawFilter) {
-            fOverdrawFilter = new OverdrawFilter;
+            fOverdrawFilter = new SkOverdrawFilter;
         }
 
         if (fOverdrawFilter != canvas->getDrawFilter()) {
             canvas->setDrawFilter(fOverdrawFilter);
         }
+    } else if (fOverrideTexFiltering) {
+        if (NULL == fTexOverrideFilter) {
+            fTexOverrideFilter = new SkTexOverrideFilter;
+        }
+
+        if (fTexOverrideFilter != canvas->getDrawFilter()) {
+            canvas->setDrawFilter(fTexOverrideFilter);
+        }
     } else {
         canvas->setDrawFilter(NULL);
     }
 
     for (; i <= index; i++) {
         if (i == index && fFilter) {
             SkPaint p;
             p.setColor(0xAAFFFFFF);
             canvas->save();
             canvas->resetMatrix();
@@ skipping 59 matching lines @@
             commandString->push_back() = fCommandVector[i]->toString();
         }
     }
     return commandString;
 }
 
 void SkDebugCanvas::toggleFilter(bool toggle) {
     fFilter = toggle;
 }
 
+void SkDebugCanvas::overrideTexFiltering(bool overrideTexFiltering, SkPaint::FilterLevel level) { 
+    if (NULL == fTexOverrideFilter) {
+        fTexOverrideFilter = new SkTexOverrideFilter;
+    }
+
+    fOverrideTexFiltering = overrideTexFiltering; 
+    fTexOverrideFilter->setFilterLevel(level);
+}
+
 void SkDebugCanvas::clear(SkColor color) {
     addDrawCommand(new SkClearCommand(color));
 }
 
 bool SkDebugCanvas::clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
     addDrawCommand(new SkClipPathCommand(path, op, doAA));
     return true;
 }
 
 bool SkDebugCanvas::clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
@@ skipping 155 matching lines @@
 
 bool SkDebugCanvas::translate(SkScalar dx, SkScalar dy) {
     addDrawCommand(new SkTranslateCommand(dx, dy));
     return true;
 }
 
 void SkDebugCanvas::toggleCommand(int index, bool toggle) {
     SkASSERT(index < fCommandVector.count());
     fCommandVector[index]->setVisible(toggle);
 }