SlidesSlide.cpp File Reference

#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkPaint.h"
#include "include/core/SkVertices.h"
#include "include/effects/SkGradientShader.h"
#include "src/core/SkBlurMask.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkWriteBuffer.h"
#include "tools/EncodeUtils.h"
#include "tools/viewer/ClickHandlerSlide.h"
#include "include/effects/Sk1DPathEffect.h"
#include "include/effects/Sk2DPathEffect.h"
#include "include/effects/SkCornerPathEffect.h"
#include "include/effects/SkDashPathEffect.h"
#include "include/effects/SkDiscretePathEffect.h"
#include "include/core/SkStream.h"
#include "src/base/SkRandom.h"
#include "src/core/SkOSFile.h"
#include "tools/DecodeUtils.h"
#include "include/core/SkTypeface.h"

Go to the source code of this file.

Classes
struct	GradData
class	Rec
class	SlidesSlide

Macros
#define	BG_COLOR   0xFFDDDDDD

Typedefs
typedef void(*	SlideProc) (SkCanvas *)
typedef void(*	PE_Proc) (SkPaint *)
typedef sk_sp< SkShader >(*	GradMaker) (const SkPoint pts[2], const GradData &, SkTileMode)

Functions
static void	compose_pe (SkPaint *paint)
static void	hair_pe (SkPaint *paint)
static void	hair2_pe (SkPaint *paint)
static void	stroke_pe (SkPaint *paint)
static void	dash_pe (SkPaint *paint)
static void	scale (SkPath *path, SkScalar scale)
static void	one_d_pe (SkPaint *paint)
static void	fill_pe (SkPaint *paint)
static void	discrete_pe (SkPaint *paint)
static sk_sp< SkPathEffect >	MakeTileEffect ()
static void	tile_pe (SkPaint *paint)
static void	patheffect_slide (SkCanvas *canvas)
static sk_sp< SkShader >	MakeLinear (const SkPoint pts[2], const GradData &data, SkTileMode tm)
static sk_sp< SkShader >	MakeRadial (const SkPoint pts[2], const GradData &data, SkTileMode tm)
static sk_sp< SkShader >	MakeSweep (const SkPoint pts[2], const GradData &data, SkTileMode tm)
static sk_sp< SkShader >	Make2Conical (const SkPoint pts[2], const GradData &data, SkTileMode tm)
static void	gradient_slide (SkCanvas *canvas)
static sk_sp< SkShader >	make_shader0 (SkIPoint *size)
static sk_sp< SkShader >	make_shader1 (const SkIPoint &size)
static void	make_tris (Rec *rec)
static void	make_fan (Rec *rec, int texWidth, int texHeight)
static void	make_strip (Rec *rec, int texWidth, int texHeight)
static void	mesh_slide (SkCanvas *canvas)

Variables
static const int	gXY []
static const PE_Proc	gPE [] = { hair_pe, hair2_pe, stroke_pe, dash_pe, one_d_pe }
static const PE_Proc	gPE2 [] = { fill_pe, discrete_pe, tile_pe }
static const SkColor	gColors []
static const SkScalar	gPos0 [] = { 0, SK_Scalar1 }
static const SkScalar	gPos1 [] = { SK_Scalar1/4, SK_Scalar1*3/4 }
static const SkScalar	gPos2 []
static const GradData	gGradData []
static const GradMaker	gGradMakers []
static const SlideProc	gProc []

Macro Definition Documentation

BG_COLOR

#define BG_COLOR   0xFFDDDDDD

Definition at line 18 of file SlidesSlide.cpp.

Typedef Documentation

GradMaker

typedef sk_sp< SkShader >(* GradMaker) (const SkPoint pts[2], const GradData &, SkTileMode)

Definition at line 207 of file SlidesSlide.cpp.

PE_Proc

typedef void(* PE_Proc) (SkPaint *)

Definition at line 87 of file SlidesSlide.cpp.

SlideProc

typedef void(* SlideProc) (SkCanvas *)

Definition at line 20 of file SlidesSlide.cpp.

Function Documentation

compose_pe()

static void compose_pe ( SkPaint *  paint )

static

Definition at line 30 of file SlidesSlide.cpp.

                                       {
    SkPathEffect* pe = paint->getPathEffect();
    sk_sp<SkPathEffect> corner = SkCornerPathEffect::Make(25);
    sk_sp<SkPathEffect> compose;
    if (pe) {
        compose = SkPathEffect::MakeCompose(sk_ref_sp(pe), corner);
    } else {
        compose = corner;
    }
    paint->setPathEffect(compose);
}

dash_pe()

static void dash_pe ( SkPaint *  paint )

static

Definition at line 56 of file SlidesSlide.cpp.

                                    {
    SkScalar inter[] = { 20, 10, 10, 10 };
    paint->setStrokeWidth(12);
    paint->setPathEffect(SkDashPathEffect::Make(inter, std::size(inter), 0));
    compose_pe(paint);
}

discrete_pe()

static void discrete_pe ( SkPaint *  paint )

static

Definition at line 95 of file SlidesSlide.cpp.

                                        {
    paint->setPathEffect(SkDiscretePathEffect::Make(10, 4));
}

fill_pe()

static void fill_pe ( SkPaint *  paint )

static

Definition at line 90 of file SlidesSlide.cpp.

                                    {
    paint->setStyle(SkPaint::kFill_Style);
    paint->setPathEffect(nullptr);
}

gradient_slide()

static void gradient_slide ( SkCanvas *  canvas )

static

Definition at line 212 of file SlidesSlide.cpp.

                                             {
    SkPoint pts[2] = {
        { 0, 0 },
        { SkIntToScalar(100), SkIntToScalar(100) }
    };
    SkTileMode tm = SkTileMode::kClamp;
    SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
    SkPaint paint;
    paint.setAntiAlias(true);
    paint.setDither(true);
 
    canvas->translate(SkIntToScalar(20), SkIntToScalar(10));
    for (size_t i = 0; i < std::size(gGradData); i++) {
        canvas->save();
        for (size_t j = 0; j < std::size(gGradMakers); j++) {
            paint.setShader(gGradMakers[j](pts, gGradData[i], tm));
            canvas->drawRect(r, paint);
            canvas->translate(0, SkIntToScalar(120));
        }
        canvas->restore();
        canvas->translate(SkIntToScalar(120), 0);
    }
}

hair2_pe()

static void hair2_pe ( SkPaint *  paint )

static

Definition at line 46 of file SlidesSlide.cpp.

                                     {
    paint->setStrokeWidth(0);
    compose_pe(paint);
}

hair_pe()

static void hair_pe ( SkPaint *  paint )

static

Definition at line 42 of file SlidesSlide.cpp.

                                    {
    paint->setStrokeWidth(0);
}

Make2Conical()

static sk_sp< SkShader > Make2Conical ( const SkPoint  pts[2], const GradData &  data, SkTileMode  tm  )

static

Definition at line 196 of file SlidesSlide.cpp.

                                                                                               {
    SkPoint center0, center1;
    center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
    center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
                SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
    return SkGradientShader::MakeTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
                                                  center0, (pts[1].fX - pts[0].fX) / 2,
                                                  data.fColors, data.fPos, data.fCount, tm);
}

make_fan()

static void make_fan ( Rec *  rec, int  texWidth, int  texHeight  )

static

Definition at line 285 of file SlidesSlide.cpp.

                                                            {
    const SkScalar tx = SkIntToScalar(texWidth);
    const SkScalar ty = SkIntToScalar(texHeight);
    const int n = 24;
 
    rec->fMode = SkVertices::kTriangleFan_VertexMode;
    rec->fCount = n + 2;
    rec->fVerts = new SkPoint[rec->fCount];
    rec->fTexs  = new SkPoint[rec->fCount];
 
    SkPoint* v = rec->fVerts;
    SkPoint* t = rec->fTexs;
 
    v[0].set(0, 0);
    t[0].set(0, 0);
    for (int i = 0; i < n; i++) {
        SkScalar r   = SK_ScalarPI * 2 * i / n,
                 sin = SkScalarSin(r),
                 cos = SkScalarCos(r);
        v[i+1].set(cos, sin);
        t[i+1].set(i*tx/n, ty);
    }
    v[n+1] = v[1];
    t[n+1].set(tx, ty);
 
    SkMatrix m;
    m.setScale(SkIntToScalar(100), SkIntToScalar(100));
    m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
    m.mapPoints(v, rec->fCount);
}

make_shader0()

static sk_sp< SkShader > make_shader0 ( SkIPoint *  size )

static

Definition at line 243 of file SlidesSlide.cpp.

                                                    {
    SkBitmap bm;
    ToolUtils::GetResourceAsBitmap("images/baby_tux.png", &bm);
    size->set(bm.width(), bm.height());
    return bm.makeShader(SkSamplingOptions(SkFilterMode::kLinear));
}

make_shader1()

static sk_sp< SkShader > make_shader1 ( const SkIPoint &  size )

static

Definition at line 250 of file SlidesSlide.cpp.

                                                          {
    SkPoint pts[] = { { 0, 0 },
                      { SkIntToScalar(size.fX), SkIntToScalar(size.fY) } };
    SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED };
    return SkGradientShader::MakeLinear(pts, colors, nullptr,
                                          std::size(colors), SkTileMode::kMirror);
}

make_strip()

static void make_strip ( Rec *  rec, int  texWidth, int  texHeight  )

static

Definition at line 316 of file SlidesSlide.cpp.

                                                              {
    const SkScalar tx = SkIntToScalar(texWidth);
    const SkScalar ty = SkIntToScalar(texHeight);
    const int n = 24;
 
    rec->fMode = SkVertices::kTriangleStrip_VertexMode;
    rec->fCount = 2 * (n + 1);
    rec->fVerts = new SkPoint[rec->fCount];
    rec->fTexs  = new SkPoint[rec->fCount];
 
    SkPoint* v = rec->fVerts;
    SkPoint* t = rec->fTexs;
 
    for (int i = 0; i < n; i++) {
        SkScalar r   = SK_ScalarPI * 2 * i / n,
                 sin = SkScalarSin(r),
                 cos = SkScalarCos(r);
        v[i*2 + 0].set(cos/2, sin/2);
        v[i*2 + 1].set(cos, sin);
 
        t[i*2 + 0].set(tx * i / n, ty);
        t[i*2 + 1].set(tx * i / n, 0);
    }
    v[2*n + 0] = v[0];
    v[2*n + 1] = v[1];
 
    t[2*n + 0].set(tx, ty);
    t[2*n + 1].set(tx, 0);
 
    SkMatrix m;
    m.setScale(SkIntToScalar(100), SkIntToScalar(100));
    m.postTranslate(SkIntToScalar(110), SkIntToScalar(110));
    m.mapPoints(v, rec->fCount);
}

make_tris()

static void make_tris ( Rec *  rec )

static

Definition at line 269 of file SlidesSlide.cpp.

                                {
    int n = 10;
    SkRandom    rand;
 
    rec->fMode = SkVertices::kTriangles_VertexMode;
    rec->fCount = n * 3;
    rec->fVerts = new SkPoint[rec->fCount];
 
    for (int i = 0; i < n; i++) {
        SkPoint* v = &rec->fVerts[i*3];
        for (int j = 0; j < 3; j++) {
            v[j].set(rand.nextUScalar1() * 250, rand.nextUScalar1() * 250);
        }
    }
}

MakeLinear()

static sk_sp< SkShader > MakeLinear ( const SkPoint  pts[2], const GradData &  data, SkTileMode  tm  )

static

Definition at line 177 of file SlidesSlide.cpp.

                                                                                             {
    return SkGradientShader::MakeLinear(pts, data.fColors, data.fPos, data.fCount, tm);
}

MakeRadial()

static sk_sp< SkShader > MakeRadial ( const SkPoint  pts[2], const GradData &  data, SkTileMode  tm  )

static

Definition at line 181 of file SlidesSlide.cpp.

                                                                                             {
    SkPoint center;
    center.set(SkScalarAve(pts[0].fX, pts[1].fX),
               SkScalarAve(pts[0].fY, pts[1].fY));
    return SkGradientShader::MakeRadial(center, center.fX, data.fColors,
                                          data.fPos, data.fCount, tm);
}

MakeSweep()

static sk_sp< SkShader > MakeSweep ( const SkPoint  pts[2], const GradData &  data, SkTileMode  tm  )

static

Definition at line 189 of file SlidesSlide.cpp.

                                                                                            {
    SkPoint center;
    center.set(SkScalarAve(pts[0].fX, pts[1].fX),
               SkScalarAve(pts[0].fY, pts[1].fY));
    return SkGradientShader::MakeSweep(center.fX, center.fY, data.fColors, data.fPos, data.fCount);
}

MakeTileEffect()

static sk_sp< SkPathEffect > MakeTileEffect ( )

static

Definition at line 99 of file SlidesSlide.cpp.

                                            {
    SkMatrix m;
    m.setScale(SkIntToScalar(12), SkIntToScalar(12));
 
    SkPath path;
    path.addCircle(0, 0, SkIntToScalar(5));
 
    return SkPath2DPathEffect::Make(m, path);
}

mesh_slide()

static void mesh_slide ( SkCanvas *  canvas )

static

Definition at line 351 of file SlidesSlide.cpp.

                                         {
    Rec fRecs[3];
    SkIPoint    size;
 
    auto fShader0 = make_shader0(&size);
    auto fShader1 = make_shader1(size);
 
    make_strip(&fRecs[0], size.fX, size.fY);
    make_fan(&fRecs[1], size.fX, size.fY);
    make_tris(&fRecs[2]);
 
    SkPaint paint;
    paint.setDither(true);
 
    for (size_t i = 0; i < std::size(fRecs); i++) {
        auto verts = SkVertices::MakeCopy(fRecs[i].fMode, fRecs[i].fCount,
                                          fRecs[i].fVerts, fRecs[i].fTexs, nullptr);
        canvas->save();
 
        paint.setShader(nullptr);
        canvas->drawVertices(verts, SkBlendMode::kModulate, paint);
 
        canvas->translate(SkIntToScalar(210), 0);
 
        paint.setShader(fShader0);
        canvas->drawVertices(verts, SkBlendMode::kModulate, paint);
 
        canvas->translate(SkIntToScalar(210), 0);
 
        paint.setShader(fShader1);
        canvas->drawVertices(verts, SkBlendMode::kModulate, paint);
        canvas->restore();
 
        canvas->translate(0, SkIntToScalar(250));
    }
}

one_d_pe()

static void one_d_pe ( SkPaint *  paint )

static

Definition at line 73 of file SlidesSlide.cpp.

                                     {
    SkPath  path;
    path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1]));
    for (unsigned i = 2; i < std::size(gXY); i += 2)
        path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1]));
    path.close();
    path.offset(SkIntToScalar(-6), 0);
    scale(&path, 1.5f);
 
    paint->setPathEffect(SkPath1DPathEffect::Make(path, SkIntToScalar(21), 0,
                                                  SkPath1DPathEffect::kRotate_Style));
    compose_pe(paint);
}

patheffect_slide()

static void patheffect_slide ( SkCanvas *  canvas )

static

Definition at line 115 of file SlidesSlide.cpp.

                                               {
    SkPaint paint;
    paint.setAntiAlias(true);
    paint.setStyle(SkPaint::kStroke_Style);
 
    SkPath path;
    path.moveTo(20, 20);
    path.lineTo(70, 120);
    path.lineTo(120, 30);
    path.lineTo(170, 80);
    path.lineTo(240, 50);
 
    size_t i;
    canvas->save();
    for (i = 0; i < std::size(gPE); i++) {
        gPE[i](&paint);
        canvas->drawPath(path, paint);
        canvas->translate(0, 75);
    }
    canvas->restore();
 
    path.reset();
    SkRect r = { 0, 0, 250, 120 };
    path.addOval(r, SkPathDirection::kCW);
    r.inset(50, 50);
    path.addRect(r, SkPathDirection::kCCW);
 
    canvas->translate(320, 20);
    for (i = 0; i < std::size(gPE2); i++) {
        gPE2[i](&paint);
        canvas->drawPath(path, paint);
        canvas->translate(0, 160);
    }
}

scale()

static void scale ( SkPath *  path, SkScalar  scale  )

static

Definition at line 67 of file SlidesSlide.cpp.

                                                {
    SkMatrix m;
    m.setScale(scale, scale);
    path->transform(m);
}

stroke_pe()

static void stroke_pe ( SkPaint *  paint )

static

Definition at line 51 of file SlidesSlide.cpp.

                                      {
    paint->setStrokeWidth(12);
    compose_pe(paint);
}

tile_pe()

static void tile_pe ( SkPaint *  paint )

static

Definition at line 109 of file SlidesSlide.cpp.

                                    {
    paint->setPathEffect(MakeTileEffect());
}

Variable Documentation

gColors

const SkColor gColors[]

static

Initial value:

= {
SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
}

Definition at line 160 of file SlidesSlide.cpp.

                                 {
SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
};

gGradData

const GradData gGradData[]

static

Initial value:

= {
{ 2, gColors, nullptr },
{ 2, gColors, gPos0 },
{ 2, gColors, gPos1 },
{ 5, gColors, nullptr },
{ 5, gColors, gPos2 }
}

Definition at line 169 of file SlidesSlide.cpp.

                                    {
{ 2, gColors, nullptr },
{ 2, gColors, gPos0 },
{ 2, gColors, gPos1 },
{ 5, gColors, nullptr },
{ 5, gColors, gPos2 }
};

gGradMakers

const GradMaker gGradMakers[]

static

Initial value:

= {
    MakeLinear, MakeRadial, MakeSweep, Make2Conical
}

Definition at line 208 of file SlidesSlide.cpp.

                                       {
    MakeLinear, MakeRadial, MakeSweep, Make2Conical
};

gPE

const PE_Proc gPE[] = { hair_pe, hair2_pe, stroke_pe, dash_pe, one_d_pe }

static

Definition at line 88 of file SlidesSlide.cpp.

{ hair_pe, hair2_pe, stroke_pe, dash_pe, one_d_pe };

gPE2

const PE_Proc gPE2[] = { fill_pe, discrete_pe, tile_pe }

static

Definition at line 113 of file SlidesSlide.cpp.

{ fill_pe, discrete_pe, tile_pe };

gPos0

const SkScalar gPos0[] = { 0, SK_Scalar1 }

static

Definition at line 163 of file SlidesSlide.cpp.

{ 0, SK_Scalar1 };

gPos1

const SkScalar gPos1[] = { SK_Scalar1/4, SK_Scalar1*3/4 }

static

Definition at line 164 of file SlidesSlide.cpp.

{ SK_Scalar1/4, SK_Scalar1*3/4 };

gPos2

const SkScalar gPos2[]

static

Initial value:

= {
0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
}

Definition at line 165 of file SlidesSlide.cpp.

                                {
0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
};

gProc

const SlideProc gProc[]

static

Initial value:

= {
    patheffect_slide,
    gradient_slide,
    mesh_slide,
}

Definition at line 395 of file SlidesSlide.cpp.

                                 {
    patheffect_slide,
    gradient_slide,
    mesh_slide,
};

gXY

const int gXY[]

static

Initial value:

= {
4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4
}

Definition at line 63 of file SlidesSlide.cpp.

                         {
4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4
};