Animated the PathUtils Sample to show path contours

samplecode/SamplePathUtils.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SampleCode.h"
+
 #include "SkCanvas.h"
+#include "SkCornerPathEffect.h"
+#include "SkDashPathEffect.h"
 #include "SkPathUtils.h"
+#include "SkRandom.h"
 #include "SkView.h"
-//#include "SkPathOps.h" // loads fine here, won't in PathUtils src files
-#include "SkRandom.h"
-//#include "SkTime.h"
+
+typedef void (*BitsToPath)(SkPath*, const char*, int, int, int);
+
+static const BitsToPath gBitsToPath_fns[] = {
+    SkPathUtils::BitsToPath_Path,
+    SkPathUtils::BitsToPath_Region,
+};
+
+// hardcoded bitmap patterns
+static const uint8_t gBits[][16] = {
+    { 0x18, 0x00, 0x3c, 0x00, 0x7e, 0x00, 0xdb, 0x00,
+      0xff, 0x00, 0x24, 0x00, 0x5a, 0x00, 0xa5, 0x00 },
+    
+    { 0x20, 0x80, 0x91, 0x20, 0xbf, 0xa0, 0xee, 0xe0,
+      0xff, 0xe0, 0x7f, 0xc0, 0x20, 0x80, 0x40, 0x40 },
+    
+    { 0x0f, 0x00, 0x7f, 0xe0, 0xff, 0xf0, 0xe6, 0x70,
+      0xff, 0xf0, 0x19, 0x80, 0x36, 0xc0, 0xc0, 0x30 }
+};
+
 
 class samplePathUtils : public SampleView {
 public:
     samplePathUtils() {
         bmp_paint.setAntiAlias(true);  // Black paint for bitmap
-    bmp_paint.setStyle(SkPaint::kFill_Style);
-        bmp_paint.setColor(SK_ColorBLACK);
+        bmp_paint.setStyle(SkPaint::kFill_Style);
+
+        outline_paint.setAntiAlias(true);  // Black paint for bitmap
+        outline_paint.setStyle(SkPaint::kStroke_Style);
+        
+        gPhase = 0.0f;
     }
 
 protected:

[scroggo, 2013/07/08 19:11:31]

nit: Need the member variables be protected?

-    static const int numModes = 3;
+    static const int numBits = 3;
     static const int h=8, w=12, stride=2; // stride is in bytes

[scroggo, 2013/07/08 19:11:31]

nit: Typically byte counts are represented as size_t. Also, in SkBitmap we use
the name 'rowBytes' instead of 'stride'. Should this be the same?

     static const int numChars = h * stride; // number of chars in entire array
 
     SkPaint bmp_paint;

[scroggo, 2013/07/08 19:11:31]

nit: In Skia we name member variables in camelCase with an 'f' at the beginning,
so this should be fBmpPaint

-
+    SkPaint outline_paint;

[scroggo, 2013/07/08 19:11:31]

nit: fOutlinePaint

+    SkScalar gPhase;

[scroggo, 2013/07/08 19:11:31]

nit: Unless this is global, it should be fPhase.

+    
     // overrides from SkEventSink
     virtual bool onQuery(SkEvent* evt) {
         if (SampleCode::TitleQ(*evt)) {
             SampleCode::TitleR(evt, "PathUtils");
             return true;
         }
         return this->INHERITED::onQuery(evt);
     }
 
     /////////////////////////////////////////////////////////////
 
     virtual void onDrawContent(SkCanvas* canvas) {

[scroggo, 2013/07/08 19:11:31]

I love SamplePathUtils's images :)

-        // bitmap definitions
-        const uint8_t bits[numModes][numChars] = {
-            { 0x18, 0x00, 0x3c, 0x00, 0x7e, 0x00, 0xdb, 0x00,
-               0xff, 0x00, 0x24, 0x00, 0x5a, 0x00, 0xa5, 0x00 },
+        // creating animated path effect composition (avoiding memory leaks)
+        SkScalar intervals[8] = {.5, .3, .5, .3, .5, .3, .5, .3};
+        SkAutoTUnref<SkDashPathEffect> dash(new SkDashPathEffect(intervals, 2, gPhase) );
+        SkAutoTUnref<SkCornerPathEffect> corner(new SkCornerPathEffect(.25f) );
+        outline_paint.setPathEffect(new SkComposePathEffect(dash, corner) )->unref();
 
-            { 0x20, 0x80, 0x91, 0x20, 0xbf, 0xa0, 0xee, 0xe0,
-              0xff, 0xe0, 0x7f, 0xc0, 0x20, 0x80, 0x40, 0x40 },
+        canvas->scale(10.0f, 10.0f);  // scales up each bitmap
+        for (int i = 0; i < numBits; ++i) {
 
-            { 0x0f, 0x00, 0x7f, 0xe0, 0xff, 0xf0, 0xe6, 0x70,
-              0xff, 0xf0, 0x19, 0x80, 0x36, 0xc0, 0xc0, 0x30 }
-        };
+            canvas->save(); 
+            for (size_t j = 0; j < SK_ARRAY_COUNT(gBitsToPath_fns); ++j) {
+                SkPath path;
+                gBitsToPath_fns[j](&path, (char*) &gBits[i], h, w, stride);

[scroggo, 2013/07/08 19:11:31]

Most of our API supplies width as a parameter before height. Shouldn't the
SkPathUtils functions use the same ordering for clarity?

 
-        static const SkScalar kScale = 10.0f;
+                //draw skPath and outline
+                canvas->drawPath(path, bmp_paint); 
+                canvas->translate(1.5f * w, 0); // translates past previous bitmap
+                canvas->drawPath(path, outline_paint);
+                canvas->translate(1.5f * w, 0); // translates past previous bitmap
+            }
+            canvas->restore();
+            canvas->translate(0, 1.5f * h); //translate to next row
+        }
 
-        for (int i = 0; i < numModes; ++i) {
-            SkPath path; // generate and simplify each path
-            SkPathUtils::BitsToPath_Path(&path, (char*) &bits[i], h, w, stride);
-
-            canvas->save(); // DRAWING
-            canvas->scale(kScale, kScale);  // scales up each bitmap
-            canvas->translate(0, 1.5f * h * i);
-            canvas->drawPath(path, bmp_paint); // draw bitmap
-            canvas->restore();
-
-            // use the SkRegion method
-            SkPath pathR;
-            SkPathUtils::BitsToPath_Region(&pathR, (char*) &bits[i], h, w, stride);
-
-            canvas->save();
-
-            canvas->scale(kScale, kScale);  // scales up each bitmap
-            canvas->translate(1.5f * w, 1.5f * h * i); // translates past previous bitmap
-            canvas->drawPath(pathR, bmp_paint); // draw bitmap
-            canvas->restore();
-        }
+        // for animated pathEffect
+        gPhase += .01;
+        this->inval(NULL);
     }
 
 private:
     typedef SkView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* MyFactory() { return new samplePathUtils; }
 static SkViewRegister reg(MyFactory)
 ;