Sk1DPathEffect.cpp File Reference

#include "include/effects/Sk1DPathEffect.h"
#include "include/core/SkFlattenable.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkPathMeasure.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkStrokeRec.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkFloatingPoint.h"
#include "src/core/SkPathEffectBase.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkWriteBuffer.h"

Go to the source code of this file.

Classes
class	Sk1DPathEffect
class	SkPath1DPathEffectImpl

Macros
#define	MAX_REASONABLE_ITERATIONS   100000

Functions
static bool	morphpoints (SkPoint dst[], const SkPoint src[], int count, SkPathMeasure &meas, SkScalar dist)
static void	morphpath (SkPath *dst, const SkPath &src, SkPathMeasure &meas, SkScalar dist)

Macro Definition Documentation

MAX_REASONABLE_ITERATIONS

#define MAX_REASONABLE_ITERATIONS   100000

Definition at line 29 of file Sk1DPathEffect.cpp.

Function Documentation

morphpath()

static void morphpath ( SkPath *  dst, const SkPath &  src, SkPathMeasure &  meas, SkScalar  dist  )

static

Definition at line 178 of file Sk1DPathEffect.cpp.

                                     {
    SkPath::Iter    iter(src, false);
    SkPoint         srcP[4], dstP[3];
    SkPath::Verb    verb;
 
    while ((verb = iter.next(srcP)) != SkPath::kDone_Verb) {
        switch (verb) {
            case SkPath::kMove_Verb:
                if (morphpoints(dstP, srcP, 1, meas, dist)) {
                    dst->moveTo(dstP[0]);
                }
                break;
            case SkPath::kLine_Verb:
                srcP[2] = srcP[1];
                srcP[1].set(SkScalarAve(srcP[0].fX, srcP[2].fX),
                            SkScalarAve(srcP[0].fY, srcP[2].fY));
                [[fallthrough]];
            case SkPath::kQuad_Verb:
                if (morphpoints(dstP, &srcP[1], 2, meas, dist)) {
                    dst->quadTo(dstP[0], dstP[1]);
                }
                break;
            case SkPath::kConic_Verb:
                if (morphpoints(dstP, &srcP[1], 2, meas, dist)) {
                    dst->conicTo(dstP[0], dstP[1], iter.conicWeight());
                }
                break;
            case SkPath::kCubic_Verb:
                if (morphpoints(dstP, &srcP[1], 3, meas, dist)) {
                    dst->cubicTo(dstP[0], dstP[1], dstP[2]);
                }
                break;
            case SkPath::kClose_Verb:
                dst->close();
                break;
            default:
                SkDEBUGFAIL("unknown verb");
                break;
        }
    }
}

morphpoints()

static bool morphpoints ( SkPoint  dst[], const SkPoint  src[], int  count, SkPathMeasure &  meas, SkScalar  dist  )

static

Definition at line 147 of file Sk1DPathEffect.cpp.

                                                            {
    for (int i = 0; i < count; i++) {
        SkPoint pos;
        SkVector tangent;
 
        SkScalar sx = src[i].fX;
        SkScalar sy = src[i].fY;
 
        if (!meas.getPosTan(dist + sx, &pos, &tangent)) {
            return false;
        }
 
        SkMatrix    matrix;
        SkPoint     pt;
 
        pt.set(sx, sy);
        matrix.setSinCos(tangent.fY, tangent.fX, 0, 0);
        matrix.preTranslate(-sx, 0);
        matrix.postTranslate(pos.fX, pos.fY);
        matrix.mapPoints(&dst[i], &pt, 1);
    }
    return true;
}