Home | History | Annotate | Download | only in samplecode 
      1 /*
      2  * Copyright 2011 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #include "Sample.h"
      9 #include "SkCanvas.h"
     10 #include "SkColorFilter.h"
     11 #include "SkColorPriv.h"
     12 #include "SkGradientShader.h"
     13 #include "SkGraphics.h"
     14 #include "SkPath.h"
     15 #include "SkRegion.h"
     16 #include "SkShader.h"
     17 #include "SkTime.h"
     18 #include "SkTo.h"
     19 #include "SkTypeface.h"
     20 #include "SkUTF.h"
     21 
     22 #include <utility>
     23 
     24 class PathClipView : public Sample {
     25 public:
     26     SkRect fOval;
     27     SkPoint fCenter;
     28 
     29     PathClipView() : fOval(SkRect::MakeWH(200, 50)), fCenter(SkPoint::Make(250, 250)) {}
     30 
     31 protected:
     32     bool onQuery(Sample::Event* evt) override {
     33         if (Sample::TitleQ(*evt)) {
     34             Sample::TitleR(evt, "PathClip");
     35             return true;
     36         }
     37         return this->INHERITED::onQuery(evt);
     38     }
     39 
     40     void onDrawContent(SkCanvas* canvas) override {
     41         const SkRect oval = fOval.makeOffset(fCenter.fX - fOval.centerX(),
     42                                              fCenter.fY - fOval.centerY());
     43 
     44         SkPaint p;
     45         p.setAntiAlias(true);
     46 
     47         p.setStyle(SkPaint::kStroke_Style);
     48         canvas->drawOval(oval, p);
     49 
     50         const SkRect r = SkRect::MakeLTRB(200, 200, 300, 300);
     51         canvas->clipRect(r);
     52 
     53         p.setStyle(SkPaint::kFill_Style);
     54         p.setColor(SK_ColorRED);
     55         canvas->drawRect(r, p);
     56 
     57         p.setColor(0x800000FF);
     58         canvas->drawOval(oval, p);
     59     }
     60 
     61     Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override {
     62         return new Click(this);
     63     }
     64 
     65     bool onClick(Click* click) override {
     66         fCenter.set(click->fCurr.fX, click->fCurr.fY);
     67         return false;
     68     }
     69 
     70 private:
     71     typedef Sample INHERITED;
     72 };
     73 DEF_SAMPLE( return new PathClipView; )
     74 
     75 //////////////////////////////////////////////////////////////////////////////
     76 
     77 static int clip_line(const SkRect& bounds, SkPoint p0, SkPoint p1, SkPoint edges[]) {
     78     SkPoint* edgesStart = edges;
     79 
     80     if (p0.fY == p1.fY) {
     81         return 0;
     82     }
     83 
     84     if (p0.fY > p1.fY) {
     85         using std::swap;
     86         swap(p0, p1);
     87     }
     88     // now we're monotonic in Y: p0 <= p1
     89     if (p1.fY <= bounds.top() || p0.fY >= bounds.bottom()) {
     90         return 0;
     91     }
     92 
     93     double dxdy = (double)(p1.fX - p0.fX) / (p1.fY - p0.fY);
     94     if (p0.fY < bounds.top()) {
     95         p0.fX = SkDoubleToScalar(p0.fX + dxdy * (bounds.top() - p0.fY));
     96         p0.fY = bounds.top();
     97     }
     98     if (p1.fY > bounds.bottom()) {
     99         p1.fX = SkDoubleToScalar(p1.fX + dxdy * (bounds.bottom() - p1.fY));
    100         p1.fY = bounds.bottom();
    101     }
    102 
    103     // Now p0...p1 is strictly inside bounds vertically, so we just need to clip horizontally
    104 
    105     if (p0.fX > p1.fX) {
    106         using std::swap;
    107         swap(p0, p1);
    108     }
    109     // now we're left-to-right: p0 .. p1
    110 
    111     if (p1.fX <= bounds.left()) {   // entirely to the left
    112         p0.fX = p1.fX = bounds.left();
    113         *edges++ = p0;
    114         *edges++ = p1;
    115         return 2;
    116     }
    117     if (p0.fX >= bounds.right()) {  // entirely to the right
    118         p0.fX = p1.fX = bounds.right();
    119         *edges++ = p0;
    120         *edges++ = p1;
    121         return 2;
    122     }
    123 
    124     if (p0.fX < bounds.left()) {
    125         float y = SkDoubleToScalar(p0.fY + (bounds.left() - p0.fX) / dxdy);
    126         *edges++ = SkPoint::Make(bounds.left(), p0.fY);
    127         *edges++ = SkPoint::Make(bounds.left(), y);
    128         p0.set(bounds.left(), y);
    129     }
    130     if (p1.fX > bounds.right()) {
    131         float y = SkDoubleToScalar(p0.fY + (bounds.right() - p0.fX) / dxdy);
    132         *edges++ = p0;
    133         *edges++ = SkPoint::Make(bounds.right(), y);
    134         *edges++ = SkPoint::Make(bounds.right(), p1.fY);
    135     } else {
    136         *edges++ = p0;
    137         *edges++ = p1;
    138     }
    139     return SkToInt(edges - edgesStart);
    140 }
    141 
    142 static void draw_clipped_line(SkCanvas* canvas, const SkRect& bounds,
    143                               SkPoint p0, SkPoint p1, const SkPaint& paint) {
    144     SkPoint verts[6];
    145     int count = clip_line(bounds, p0, p1, verts);
    146 
    147     SkPath path;
    148     path.addPoly(verts, count, false);
    149     canvas->drawPath(path, paint);
    150 }
    151 
    152 // Demonstrate edge-clipping that is used in the scan converter
    153 //
    154 class EdgeClipView : public Sample {
    155     enum {
    156         N = 3
    157     };
    158 public:
    159     SkPoint fPoly[N];
    160     SkRect  fClip;
    161     SkColor fEdgeColor[N];
    162 
    163     EdgeClipView() : fClip(SkRect::MakeLTRB(150, 150, 550, 450)) {
    164         fPoly[0].set(300, 40);
    165         fPoly[1].set(550, 250);
    166         fPoly[2].set(40, 450);
    167 
    168         fEdgeColor[0] = 0xFFFF0000;
    169         fEdgeColor[1] = 0xFF00FF00;
    170         fEdgeColor[2] = 0xFF0000FF;
    171     }
    172 
    173 protected:
    174     bool onQuery(Sample::Event* evt) override {
    175         if (Sample::TitleQ(*evt)) {
    176             Sample::TitleR(evt, "EdgeClip");
    177             return true;
    178         }
    179         return this->INHERITED::onQuery(evt);
    180     }
    181 
    182     static SkScalar snap(SkScalar x) {
    183         return SkScalarRoundToScalar(x * 0.5f) * 2;
    184     }
    185     static SkPoint snap(const SkPoint& pt) {
    186         return SkPoint::Make(snap(pt.x()), snap(pt.y()));
    187     }
    188     static void snap(SkPoint dst[], const SkPoint src[], int count) {
    189         for (int i = 0; i < count; ++i) {
    190             dst[i] = snap(src[i]);
    191         }
    192     }
    193 
    194     void onDrawContent(SkCanvas* canvas) override {
    195         SkPath path;
    196         path.addPoly(fPoly, N, true);
    197 
    198         // Draw the full triangle, stroked and filled
    199         SkPaint p;
    200         p.setAntiAlias(true);
    201         p.setColor(0xFFE0E0E0);
    202         canvas->drawPath(path, p);
    203         p.setStyle(SkPaint::kStroke_Style);
    204         p.setStrokeWidth(2);
    205         for (int i = 0; i < N; ++i) {
    206             const int j = (i + 1) % N;
    207             p.setColor(fEdgeColor[i]);
    208             p.setAlpha(0x88);
    209             canvas->drawLine(fPoly[i], fPoly[j], p);
    210         }
    211         p.setStyle(SkPaint::kFill_Style);
    212 
    213         // Draw the clip itself
    214         p.setColor(0xFF8888CC);
    215         canvas->drawRect(fClip, p);
    216 
    217         // Draw the filled triangle through the clip
    218         p.setColor(0xFF88CC88);
    219         canvas->save();
    220         canvas->clipRect(fClip);
    221         canvas->drawPath(path, p);
    222         canvas->restore();
    223 
    224         p.setStyle(SkPaint::kStroke_Style);
    225         p.setStrokeWidth(6);
    226 
    227         // Draw each of the "Edges" that survived the clipping
    228         // We use a layer, so we can PLUS the different edge-colors, showing where two edges
    229         // canceled each other out.
    230         canvas->saveLayer(nullptr, nullptr);
    231         p.setBlendMode(SkBlendMode::kPlus);
    232         for (int i = 0; i < N; ++i) {
    233             const int j = (i + 1) % N;
    234             p.setColor(fEdgeColor[i]);
    235             draw_clipped_line(canvas, fClip, fPoly[i], fPoly[j], p);
    236         }
    237         canvas->restore();
    238     }
    239 
    240     class MyClick : public Click {
    241     public:
    242         MyClick(Sample* view) : Click(view) {}
    243         virtual void handleMove() = 0;
    244     };
    245 
    246     class VertClick : public MyClick {
    247         SkPoint* fPt;
    248     public:
    249         VertClick(Sample* view, SkPoint* pt) : MyClick(view), fPt(pt) {}
    250         void handleMove() override { *fPt = snap(fCurr); }
    251     };
    252 
    253     class DragRectClick : public MyClick {
    254         SkRect* fRect;
    255     public:
    256         DragRectClick(Sample* view, SkRect* rect) : MyClick(view), fRect(rect) {}
    257         void handleMove() override { fRect->offset(fCurr.x() - fPrev.x(), fCurr.y() - fPrev.y()); }
    258     };
    259 
    260     class DragPolyClick : public MyClick {
    261         SkPoint fSrc[100];
    262         SkPoint* fPoly;
    263         int fCount;
    264     public:
    265         DragPolyClick(Sample* view, SkPoint poly[], int count)
    266             : MyClick(view), fPoly(poly), fCount(count)
    267         {
    268             SkASSERT((size_t)count <= SK_ARRAY_COUNT(fSrc));
    269             memcpy(fSrc, poly, count * sizeof(SkPoint));
    270         }
    271         void handleMove() override {
    272             const SkScalar dx = fCurr.x() - fOrig.x();
    273             const SkScalar dy = fCurr.y() - fOrig.y();
    274             for (int i = 0; i < fCount; ++i) {
    275                 fPoly[i].set(snap(fSrc[i].x() + dx), snap(fSrc[i].y() + dy));
    276             }
    277         }
    278     };
    279 
    280     class DoNothingClick : public MyClick {
    281     public:
    282         DoNothingClick(Sample* view) : MyClick(view) {}
    283         void handleMove() override {}
    284     };
    285 
    286     static bool hit_test(const SkPoint& pt, SkScalar x, SkScalar y) {
    287         const SkScalar rad = 8;
    288         const SkScalar dx = pt.x() - x;
    289         const SkScalar dy = pt.y() - y;
    290         return dx*dx + dy*dy <= rad*rad;
    291     }
    292 
    293     Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override {
    294         for (int i = 0; i < N; ++i) {
    295             if (hit_test(fPoly[i], x, y)) {
    296                 return new VertClick(this, &fPoly[i]);
    297             }
    298         }
    299 
    300         SkPath path;
    301         path.addPoly(fPoly, N, true);
    302         if (path.contains(x, y)) {
    303             return new DragPolyClick(this, fPoly, N);
    304         }
    305 
    306         if (fClip.intersects(SkRect::MakeLTRB(x - 1, y - 1, x + 1, y + 1))) {
    307             return new DragRectClick(this, &fClip);
    308         }
    309         return new DoNothingClick(this);
    310     }
    311 
    312     bool onClick(Click* click) override {
    313         ((MyClick*)click)->handleMove();
    314         return false;
    315     }
    316 
    317 private:
    318     typedef Sample INHERITED;
    319 };
    320 
    321 DEF_SAMPLE( return new EdgeClipView; )
    322