pathkit_wasm_bindings.cpp File Reference

#include "include/core/SkCubicMap.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkPathUtils.h"
#include "include/core/SkRect.h"
#include "include/core/SkString.h"
#include "include/core/SkStrokeRec.h"
#include "include/effects/SkDashPathEffect.h"
#include "include/effects/SkTrimPathEffect.h"
#include "include/pathops/SkPathOps.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/utils/SkParsePath.h"
#include "src/base/SkFloatBits.h"
#include "src/core/SkPaintDefaults.h"
#include "src/core/SkPathPriv.h"
#include <emscripten.h>
#include <emscripten/bind.h>

Go to the source code of this file.

Classes
struct	StrokeOpts
struct	SimpleMatrix

Macros
#define	CHECK_NUM_ARGS(n)

Typedefs
using	SkPathOrNull = emscripten::val
using	JSString = emscripten::val
using	JSArray = emscripten::val

Functions
JSArray EMSCRIPTEN_KEEPALIVE	ToCmds (const SkPath &path)
SkPathOrNull EMSCRIPTEN_KEEPALIVE	FromCmds (uintptr_t cptr, int numCmds)
SkPath EMSCRIPTEN_KEEPALIVE	NewPath ()
SkPath EMSCRIPTEN_KEEPALIVE	CopyPath (const SkPath &a)
bool EMSCRIPTEN_KEEPALIVE	Equals (const SkPath &a, const SkPath &b)
void	ApplyArcTo (SkPath &p, SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar radius)
void	ApplyClose (SkPath &p)
void	ApplyConicTo (SkPath &p, SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar w)
void	ApplyCubicTo (SkPath &p, SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)
void	ApplyLineTo (SkPath &p, SkScalar x, SkScalar y)
void	ApplyMoveTo (SkPath &p, SkScalar x, SkScalar y)
void	ApplyQuadTo (SkPath &p, SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2)
bool EMSCRIPTEN_KEEPALIVE	IsEmpty (const SkPath &path)
JSString EMSCRIPTEN_KEEPALIVE	ToSVGString (const SkPath &path)
SkPathOrNull EMSCRIPTEN_KEEPALIVE	FromSVGString (std::string str)
bool EMSCRIPTEN_KEEPALIVE	ApplySimplify (SkPath &path)
bool EMSCRIPTEN_KEEPALIVE	ApplyAsWinding (SkPath &path)
bool EMSCRIPTEN_KEEPALIVE	ApplyPathOp (SkPath &pathOne, const SkPath &pathTwo, SkPathOp op)
SkPathOrNull EMSCRIPTEN_KEEPALIVE	MakeFromOp (const SkPath &pathOne, const SkPath &pathTwo, SkPathOp op)
SkPathOrNull EMSCRIPTEN_KEEPALIVE	ResolveBuilder (SkOpBuilder &builder)
void EMSCRIPTEN_KEEPALIVE	ToCanvas (const SkPath &path, emscripten::val ctx)
emscripten::val EMSCRIPTEN_KEEPALIVE	ToPath2D (const SkPath &path)
void	ApplyAddRect (SkPath &path, SkScalar x, SkScalar y, SkScalar width, SkScalar height)
void	ApplyAddArc (SkPath &path, SkScalar x, SkScalar y, SkScalar radius, SkScalar startAngle, SkScalar endAngle, bool ccw)
void	ApplyEllipse (SkPath &path, SkScalar x, SkScalar y, SkScalar radiusX, SkScalar radiusY, SkScalar rotation, SkScalar startAngle, SkScalar endAngle, bool ccw)
void	ApplyAddPath (SkPath &orig, const SkPath &newPath, SkScalar scaleX, SkScalar skewX, SkScalar transX, SkScalar skewY, SkScalar scaleY, SkScalar transY, SkScalar pers0, SkScalar pers1, SkScalar pers2)
void	ApplyReverseAddPath (SkPath &orig, const SkPath &newPath)
JSString	GetFillTypeString (const SkPath &path)
bool	ApplyDash (SkPath &path, SkScalar on, SkScalar off, SkScalar phase)
bool	ApplyTrim (SkPath &path, SkScalar startT, SkScalar stopT, bool isComplement)
bool	ApplyStroke (SkPath &path, StrokeOpts opts)
SkMatrix	toSkMatrix (const SimpleMatrix &sm)
void	ApplyTransform (SkPath &orig, const SimpleMatrix &sm)
void	ApplyTransform (SkPath &orig, SkScalar scaleX, SkScalar skewX, SkScalar transX, SkScalar skewY, SkScalar scaleY, SkScalar transY, SkScalar pers0, SkScalar pers1, SkScalar pers2)
float	SkBits2FloatUnsigned (uint32_t floatAsBits)
	EMSCRIPTEN_BINDINGS (skia)

Variables
static const int	MOVE = 0
static const int	LINE = 1
static const int	QUAD = 2
static const int	CONIC = 3
static const int	CUBIC = 4
static const int	CLOSE = 5
emscripten::val	JSPath2D = emscripten::val::global("Path2D")

Macro Definition Documentation

CHECK_NUM_ARGS

#define CHECK_NUM_ARGS

(

n

)

Value:

        if ((i + n) > numCmds) { \
            SkDebugf("Not enough args to match the verbs. Saw %d commands\n", numCmds); \
            return emscripten::val::null(); \
        }

Typedef Documentation

JSArray

using JSArray = emscripten::val

Definition at line 45 of file pathkit_wasm_bindings.cpp.

JSString

using JSString = emscripten::val

Definition at line 44 of file pathkit_wasm_bindings.cpp.

SkPathOrNull

using SkPathOrNull = emscripten::val

Definition at line 42 of file pathkit_wasm_bindings.cpp.

Function Documentation

ApplyAddArc()

void ApplyAddArc	(	SkPath &	path,
		SkScalar	x,
		SkScalar	y,
		SkScalar	radius,
		SkScalar	startAngle,
		SkScalar	endAngle,
		bool	ccw
	)

Definition at line 320 of file pathkit_wasm_bindings.cpp.

                                                                {
    SkPath temp;
    SkRect bounds = SkRect::MakeLTRB(x-radius, y-radius, x+radius, y+radius);
    const auto sweep = SkRadiansToDegrees(endAngle - startAngle) - 360 * ccw;
    temp.addArc(bounds, SkRadiansToDegrees(startAngle), sweep);
    path.addPath(temp, SkPath::kExtend_AddPathMode);
}

ApplyAddPath()

void ApplyAddPath	(	SkPath &	orig,
		const SkPath &	newPath,
		SkScalar	scaleX,
		SkScalar	skewX,
		SkScalar	transX,
		SkScalar	skewY,
		SkScalar	scaleY,
		SkScalar	transY,
		SkScalar	pers0,
		SkScalar	pers1,
		SkScalar	pers2
	)

Definition at line 344 of file pathkit_wasm_bindings.cpp.

                                                                   {
    SkMatrix m = SkMatrix::MakeAll(scaleX, skewX , transX,
                                   skewY , scaleY, transY,
                                   pers0 , pers1 , pers2);
    orig.addPath(newPath, m);
}

ApplyAddRect()

void ApplyAddRect	(	SkPath &	path,
		SkScalar	x,
		SkScalar	y,
		SkScalar	width,
		SkScalar	height
	)

Definition at line 316 of file pathkit_wasm_bindings.cpp.

                                                                                         {
    path.addRect(x, y, x+width, y+height);
}

ApplyArcTo()

void ApplyArcTo	(	SkPath &	p,
		SkScalar	x1,
		SkScalar	y1,
		SkScalar	x2,
		SkScalar	y2,
		SkScalar	radius
	)

Definition at line 176 of file pathkit_wasm_bindings.cpp.

                                 {
    p.arcTo(x1, y1, x2, y2, radius);
}

ApplyAsWinding()

bool EMSCRIPTEN_KEEPALIVE ApplyAsWinding

(

SkPath &

path

)

Definition at line 242 of file pathkit_wasm_bindings.cpp.

                                                       {
    return AsWinding(path, &path);
}

ApplyClose()

void ApplyClose

(

SkPath &

p

)

Definition at line 181 of file pathkit_wasm_bindings.cpp.

                           {
    p.close();
}

ApplyConicTo()

void ApplyConicTo	(	SkPath &	p,
		SkScalar	x1,
		SkScalar	y1,
		SkScalar	x2,
		SkScalar	y2,
		SkScalar	w
	)

Definition at line 185 of file pathkit_wasm_bindings.cpp.

                              {
    p.conicTo(x1, y1, x2, y2, w);
}

ApplyCubicTo()

void ApplyCubicTo	(	SkPath &	p,
		SkScalar	x1,
		SkScalar	y1,
		SkScalar	x2,
		SkScalar	y2,
		SkScalar	x3,
		SkScalar	y3
	)

Definition at line 190 of file pathkit_wasm_bindings.cpp.

                                            {
    p.cubicTo(x1, y1, x2, y2, x3, y3);
}

ApplyDash()

bool ApplyDash	(	SkPath &	path,
		SkScalar	on,
		SkScalar	off,
		SkScalar	phase
	)

Definition at line 374 of file pathkit_wasm_bindings.cpp.

                                                                        {
    SkScalar intervals[] = { on, off };
    auto pe = SkDashPathEffect::Make(intervals, 2, phase);
    if (!pe) {
        SkDebugf("Invalid args to dash()\n");
        return false;
    }
    SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
    if (pe->filterPath(&path, path, &rec, nullptr)) {
        return true;
    }
    SkDebugf("Could not make dashed path\n");
    return false;
}

ApplyEllipse()

void ApplyEllipse	(	SkPath &	path,
		SkScalar	x,
		SkScalar	y,
		SkScalar	radiusX,
		SkScalar	radiusY,
		SkScalar	rotation,
		SkScalar	startAngle,
		SkScalar	endAngle,
		bool	ccw
	)

Definition at line 329 of file pathkit_wasm_bindings.cpp.

                                                                                          {
    // This is easiest to do by making a new path and then extending the current path
    // (this properly catches the cases of if there's a moveTo before this call or not).
    SkRect bounds = SkRect::MakeLTRB(x-radiusX, y-radiusY, x+radiusX, y+radiusY);
    SkPath temp;
    const auto sweep = SkRadiansToDegrees(endAngle - startAngle) - (360 * ccw);
    temp.addArc(bounds, SkRadiansToDegrees(startAngle), sweep);
 
    SkMatrix m;
    m.setRotate(SkRadiansToDegrees(rotation), x, y);
    path.addPath(temp, m, SkPath::kExtend_AddPathMode);
}

ApplyLineTo()

void ApplyLineTo	(	SkPath &	p,
		SkScalar	x,
		SkScalar	y
	)

Definition at line 195 of file pathkit_wasm_bindings.cpp.

                                                    {
    p.lineTo(x, y);
}

ApplyMoveTo()

void ApplyMoveTo	(	SkPath &	p,
		SkScalar	x,
		SkScalar	y
	)

Definition at line 199 of file pathkit_wasm_bindings.cpp.

                                                    {
    p.moveTo(x, y);
}

ApplyPathOp()

bool EMSCRIPTEN_KEEPALIVE ApplyPathOp	(	SkPath &	pathOne,
		const SkPath &	pathTwo,
		SkPathOp	op
	)

Definition at line 246 of file pathkit_wasm_bindings.cpp.

                                                                                           {
    return Op(pathOne, pathTwo, op, &pathOne);
}

ApplyQuadTo()

void ApplyQuadTo	(	SkPath &	p,
		SkScalar	x1,
		SkScalar	y1,
		SkScalar	x2,
		SkScalar	y2
	)

Definition at line 203 of file pathkit_wasm_bindings.cpp.

                                                                                {
    p.quadTo(x1, y1, x2, y2);
}

ApplyReverseAddPath()

void ApplyReverseAddPath	(	SkPath &	orig,
		const SkPath &	newPath
	)

Definition at line 354 of file pathkit_wasm_bindings.cpp.

                                                              {
    orig.reverseAddPath(newPath);
}

ApplySimplify()

bool EMSCRIPTEN_KEEPALIVE ApplySimplify

(

SkPath &

path

)

Definition at line 238 of file pathkit_wasm_bindings.cpp.

                                                      {
    return Simplify(path, &path);
}

ApplyStroke()

bool ApplyStroke	(	SkPath &	path,
		StrokeOpts	opts
	)

Definition at line 415 of file pathkit_wasm_bindings.cpp.

                                                {
    SkPaint p;
    p.setStyle(SkPaint::kStroke_Style);
    p.setStrokeCap(opts.cap);
    p.setStrokeJoin(opts.join);
    p.setStrokeWidth(opts.width);
    p.setStrokeMiter(opts.miter_limit);
    // Default to 1.0 if 0 (or an invalid negative number)
    if (opts.res_scale <= 0) {
        opts.res_scale = 1.0;
    }
    return skpathutils::FillPathWithPaint(path, p, &path, nullptr, opts.res_scale);
}

ApplyTransform() [1/2]

void ApplyTransform	(	SkPath &	orig,
		const SimpleMatrix &	sm
	)

Definition at line 445 of file pathkit_wasm_bindings.cpp.

                                                          {
    orig.transform(toSkMatrix(sm));
}

ApplyTransform() [2/2]

void ApplyTransform	(	SkPath &	orig,
		SkScalar	scaleX,
		SkScalar	skewX,
		SkScalar	transX,
		SkScalar	skewY,
		SkScalar	scaleY,
		SkScalar	transY,
		SkScalar	pers0,
		SkScalar	pers1,
		SkScalar	pers2
	)

Definition at line 449 of file pathkit_wasm_bindings.cpp.

                                                                    {
    SkMatrix m = SkMatrix::MakeAll(scaleX, skewX , transX,
                                   skewY , scaleY, transY,
                                   pers0 , pers1 , pers2);
    orig.transform(m);
}

ApplyTrim()

bool ApplyTrim	(	SkPath &	path,
		SkScalar	startT,
		SkScalar	stopT,
		bool	isComplement
	)

Definition at line 389 of file pathkit_wasm_bindings.cpp.

                                                                                 {
    auto mode = isComplement ? SkTrimPathEffect::Mode::kInverted : SkTrimPathEffect::Mode::kNormal;
    auto pe = SkTrimPathEffect::Make(startT, stopT, mode);
    if (!pe) {
        SkDebugf("Invalid args to trim(): startT and stopT must be in [0,1]\n");
        return false;
    }
    SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
    if (pe->filterPath(&path, path, &rec, nullptr)) {
        return true;
    }
    SkDebugf("Could not trim path\n");
    return false;
}

CopyPath()

SkPath EMSCRIPTEN_KEEPALIVE CopyPath

(

const SkPath &

a

)

Definition at line 157 of file pathkit_wasm_bindings.cpp.

                                                      {
    SkPath copy(a);
    return copy;
}

EMSCRIPTEN_BINDINGS()

EMSCRIPTEN_BINDINGS

(

skia

)

Definition at line 487 of file pathkit_wasm_bindings.cpp.

                          {
    class_<SkPath>("SkPath")
        .constructor<>()
        .constructor<const SkPath&>()
 
        // Path2D API
        .function("_addPath", &ApplyAddPath)
        .function("_reverseAddPath", &ApplyReverseAddPath)
        // 3 additional overloads of addPath are handled in JS bindings
        .function("_arc", &ApplyAddArc)
        .function("_arcTo", &ApplyArcTo)
        //"bezierCurveTo" alias handled in JS bindings
        .function("_close", &ApplyClose)
        //"closePath" alias handled in JS bindings
        .function("_conicTo", &ApplyConicTo)
        .function("_cubicTo", &ApplyCubicTo)
 
        .function("_ellipse", &ApplyEllipse)
        .function("_lineTo", &ApplyLineTo)
        .function("_moveTo", &ApplyMoveTo)
        // "quadraticCurveTo" alias handled in JS bindings
        .function("_quadTo", &ApplyQuadTo)
        .function("_rect", &ApplyAddRect)
        .function("_isEmpty", &IsEmpty)
 
        // Extra features
        .function("setFillType", select_overload<void(SkPathFillType)>(&SkPath::setFillType))
        .function("getFillType", &SkPath::getFillType)
        .function("getFillTypeString", &GetFillTypeString)
        .function("getBounds", &SkPath::getBounds)
        .function("computeTightBounds", &SkPath::computeTightBounds)
        .function("equals", &Equals)
        .function("copy", &CopyPath)
 
        // PathEffects
        .function("_dash", &ApplyDash)
        .function("_trim", &ApplyTrim)
        .function("_stroke", &ApplyStroke)
 
        // Matrix
        .function("_transform", select_overload<void(SkPath& orig, const SimpleMatrix& sm)>(&ApplyTransform))
        .function("_transform", select_overload<void(SkPath& orig, SkScalar, SkScalar, SkScalar, SkScalar, SkScalar, SkScalar, SkScalar, SkScalar, SkScalar)>(&ApplyTransform))
 
        // PathOps
        .function("_simplify", &ApplySimplify)
        .function("_asWinding", &ApplyAsWinding)
        .function("_op", &ApplyPathOp)
 
        // Exporting
        .function("toCmds", &ToCmds)
        .function("toPath2D", &ToPath2D)
        .function("toCanvas", &ToCanvas)
        .function("toSVGString", &ToSVGString)
 
#ifdef PATHKIT_TESTING
        .function("dump", select_overload<void() const>(&SkPath::dump))
        .function("dumpHex", select_overload<void() const>(&SkPath::dumpHex))
#endif
        ;
 
    class_<SkOpBuilder>("SkOpBuilder")
        .constructor<>()
 
        .function("add", &SkOpBuilder::add)
        .function("make", &ResolveBuilder)
        .function("resolve", &ResolveBuilder);
 
    // Without these function() bindings, the function would be exposed but oblivious to
    // our types (e.g. SkPath)
 
    // Import
    function("FromSVGString", &FromSVGString);
    function("NewPath", &NewPath);
    function("NewPath", &CopyPath);
    // FromCmds is defined in helper.js to make use of TypedArrays transparent.
    function("_FromCmds", &FromCmds);
    // Path2D is opaque, so we can't read in from it.
 
    // PathOps
    function("MakeFromOp", &MakeFromOp);
 
    enum_<SkPathOp>("PathOp")
        .value("DIFFERENCE",         SkPathOp::kDifference_SkPathOp)
        .value("INTERSECT",          SkPathOp::kIntersect_SkPathOp)
        .value("UNION",              SkPathOp::kUnion_SkPathOp)
        .value("XOR",                SkPathOp::kXOR_SkPathOp)
        .value("REVERSE_DIFFERENCE", SkPathOp::kReverseDifference_SkPathOp);
 
    enum_<SkPathFillType>("FillType")
        .value("WINDING",            SkPathFillType::kWinding)
        .value("EVENODD",            SkPathFillType::kEvenOdd)
        .value("INVERSE_WINDING",    SkPathFillType::kInverseWinding)
        .value("INVERSE_EVENODD",    SkPathFillType::kInverseEvenOdd);
 
    constant("MOVE_VERB",  MOVE);
    constant("LINE_VERB",  LINE);
    constant("QUAD_VERB",  QUAD);
    constant("CONIC_VERB", CONIC);
    constant("CUBIC_VERB", CUBIC);
    constant("CLOSE_VERB", CLOSE);
 
    // A value object is much simpler than a class - it is returned as a JS
    // object and does not require delete().
    // https://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/embind.html#value-types
    value_object<SkRect>("SkRect")
        .field("fLeft",   &SkRect::fLeft)
        .field("fTop",    &SkRect::fTop)
        .field("fRight",  &SkRect::fRight)
        .field("fBottom", &SkRect::fBottom);
 
    function("LTRBRect", &SkRect::MakeLTRB);
 
    // Stroke
    enum_<SkPaint::Join>("StrokeJoin")
        .value("MITER", SkPaint::Join::kMiter_Join)
        .value("ROUND", SkPaint::Join::kRound_Join)
        .value("BEVEL", SkPaint::Join::kBevel_Join);
 
    enum_<SkPaint::Cap>("StrokeCap")
        .value("BUTT",   SkPaint::Cap::kButt_Cap)
        .value("ROUND",  SkPaint::Cap::kRound_Cap)
        .value("SQUARE", SkPaint::Cap::kSquare_Cap);
 
    value_object<StrokeOpts>("StrokeOpts")
        .field("width",       &StrokeOpts::width)
        .field("miter_limit", &StrokeOpts::miter_limit)
        .field("res_scale",   &StrokeOpts::res_scale)
        .field("join",        &StrokeOpts::join)
        .field("cap",         &StrokeOpts::cap);
 
    // Matrix
    // Allows clients to supply a 1D array of 9 elements and the bindings
    // will automatically turn it into a 3x3 2D matrix.
    // e.g. path.transform([0,1,2,3,4,5,6,7,8])
    // This is likely simpler for the client than exposing SkMatrix
    // directly and requiring them to do a lot of .delete().
    value_array<SimpleMatrix>("SkMatrix")
        .element(&SimpleMatrix::scaleX)
        .element(&SimpleMatrix::skewX)
        .element(&SimpleMatrix::transX)
 
        .element(&SimpleMatrix::skewY)
        .element(&SimpleMatrix::scaleY)
        .element(&SimpleMatrix::transY)
 
        .element(&SimpleMatrix::pers0)
        .element(&SimpleMatrix::pers1)
        .element(&SimpleMatrix::pers2);
 
    value_array<SkPoint>("SkPoint")
        .element(&SkPoint::fX)
        .element(&SkPoint::fY);
 
    // Not intended for external clients to call directly.
    // See helper.js for the client-facing implementation.
    class_<SkCubicMap>("_SkCubicMap")
        .constructor<SkPoint, SkPoint>()
 
        .function("computeYFromX", &SkCubicMap::computeYFromX)
        .function("computePtFromT", &SkCubicMap::computeFromT);
 
 
    // Test Utils
    function("SkBits2FloatUnsigned", &SkBits2FloatUnsigned);
}

Equals()

bool EMSCRIPTEN_KEEPALIVE Equals	(	const SkPath &	a,
		const SkPath &	b
	)

Definition at line 162 of file pathkit_wasm_bindings.cpp.

                                                                   {
    return a == b;
}

FromCmds()

SkPathOrNull EMSCRIPTEN_KEEPALIVE FromCmds	(	uintptr_t	cptr,
		int	numCmds
	)

Definition at line 95 of file pathkit_wasm_bindings.cpp.

                                                                          {
    const auto* cmds = reinterpret_cast<const float*>(cptr);
    SkPath path;
    float x1, y1, x2, y2, x3, y3;
 
    // if there are not enough arguments, bail with the path we've constructed so far.
    #define CHECK_NUM_ARGS(n) \
        if ((i + n) > numCmds) { \
            SkDebugf("Not enough args to match the verbs. Saw %d commands\n", numCmds); \
            return emscripten::val::null(); \
        }
 
    for(int i = 0; i < numCmds;){
         switch (sk_float_floor2int(cmds[i++])) {
            case MOVE:
                CHECK_NUM_ARGS(2)
                x1 = cmds[i++]; y1 = cmds[i++];
                path.moveTo(x1, y1);
                break;
            case LINE:
                CHECK_NUM_ARGS(2)
                x1 = cmds[i++]; y1 = cmds[i++];
                path.lineTo(x1, y1);
                break;
            case QUAD:
                CHECK_NUM_ARGS(4)
                x1 = cmds[i++]; y1 = cmds[i++];
                x2 = cmds[i++]; y2 = cmds[i++];
                path.quadTo(x1, y1, x2, y2);
                break;
            case CONIC:
                CHECK_NUM_ARGS(5)
                x1 = cmds[i++]; y1 = cmds[i++];
                x2 = cmds[i++]; y2 = cmds[i++];
                x3 = cmds[i++]; // weight
                path.conicTo(x1, y1, x2, y2, x3);
                break;
            case CUBIC:
                CHECK_NUM_ARGS(6)
                x1 = cmds[i++]; y1 = cmds[i++];
                x2 = cmds[i++]; y2 = cmds[i++];
                x3 = cmds[i++]; y3 = cmds[i++];
                path.cubicTo(x1, y1, x2, y2, x3, y3);
                break;
            case CLOSE:
                path.close();
                break;
            default:
                SkDebugf("  path: UNKNOWN command %f, aborting dump...\n", cmds[i-1]);
                return emscripten::val::null();
        }
    }
 
    #undef CHECK_NUM_ARGS
 
    return emscripten::val(path);
}

FromSVGString()

SkPathOrNull EMSCRIPTEN_KEEPALIVE FromSVGString

(

std::string

str

)

Definition at line 226 of file pathkit_wasm_bindings.cpp.

                                                               {
    SkPath path;
    if (SkParsePath::FromSVGString(str.c_str(), &path)) {
        return emscripten::val(path);
    }
    return emscripten::val::null();
}

GetFillTypeString()

JSString GetFillTypeString

(

const SkPath &

path

)

Definition at line 359 of file pathkit_wasm_bindings.cpp.

                                               {
    if (path.getFillType() == SkPathFillType::kWinding) {
        return emscripten::val("nonzero");
    } else if (path.getFillType() == SkPathFillType::kEvenOdd) {
        return emscripten::val("evenodd");
    } else {
        SkDebugf("warning: can't translate inverted filltype to HTML Canvas\n");
        return emscripten::val("nonzero"); //Use default
    }
}

IsEmpty()

bool EMSCRIPTEN_KEEPALIVE IsEmpty

(

const SkPath &

path

)

Definition at line 207 of file pathkit_wasm_bindings.cpp.

                                                      {
    return path.isEmpty();
}

MakeFromOp()

SkPathOrNull EMSCRIPTEN_KEEPALIVE MakeFromOp	(	const SkPath &	pathOne,
		const SkPath &	pathTwo,
		SkPathOp	op
	)

Definition at line 250 of file pathkit_wasm_bindings.cpp.

                                                                                                        {
    SkPath out;
    if (Op(pathOne, pathTwo, op, &out)) {
        return emscripten::val(out);
    }
    return emscripten::val::null();
}

NewPath()

SkPath EMSCRIPTEN_KEEPALIVE NewPath

(

)

Definition at line 153 of file pathkit_wasm_bindings.cpp.

                                      {
    return SkPath();
}

ResolveBuilder()

SkPathOrNull EMSCRIPTEN_KEEPALIVE ResolveBuilder

(

SkOpBuilder &

builder

)

Definition at line 258 of file pathkit_wasm_bindings.cpp.

                                                                       {
    SkPath path;
    if (builder.resolve(&path)) {
        return emscripten::val(path);
    }
    return emscripten::val::null();
}

SkBits2FloatUnsigned()

float SkBits2FloatUnsigned

(

uint32_t

floatAsBits

)

Definition at line 468 of file pathkit_wasm_bindings.cpp.

                                                 {
    return SkBits2Float((int32_t) floatAsBits);
}

ToCanvas()

void EMSCRIPTEN_KEEPALIVE ToCanvas	(	const SkPath &	path,
		emscripten::val	ctx
	)

Definition at line 270 of file pathkit_wasm_bindings.cpp.

                                                                            {
    SkPath::Iter iter(path, false);
    SkPoint pts[4];
    SkPath::Verb verb;
    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
        switch (verb) {
            case SkPath::kMove_Verb:
                ctx.call<void>("moveTo", pts[0].x(), pts[0].y());
                break;
            case SkPath::kLine_Verb:
                ctx.call<void>("lineTo", pts[1].x(), pts[1].y());
                break;
            case SkPath::kQuad_Verb:
                ctx.call<void>("quadraticCurveTo", pts[1].x(), pts[1].y(), pts[2].x(), pts[2].y());
                break;
            case SkPath::kConic_Verb:
                SkPoint quads[5];
                // approximate with 2^1=2 quads.
                SkPath::ConvertConicToQuads(pts[0], pts[1], pts[2], iter.conicWeight(), quads, 1);
                ctx.call<void>("quadraticCurveTo", quads[1].x(), quads[1].y(), quads[2].x(), quads[2].y());
                ctx.call<void>("quadraticCurveTo", quads[3].x(), quads[3].y(), quads[4].x(), quads[4].y());
                break;
            case SkPath::kCubic_Verb:
                ctx.call<void>("bezierCurveTo", pts[1].x(), pts[1].y(), pts[2].x(), pts[2].y(),
                                                   pts[3].x(), pts[3].y());
                break;
            case SkPath::kClose_Verb:
                ctx.call<void>("closePath");
                break;
            case SkPath::kDone_Verb:
                break;
        }
    }
}

ToCmds()

JSArray EMSCRIPTEN_KEEPALIVE ToCmds

(

const SkPath &

path

)

Definition at line 51 of file pathkit_wasm_bindings.cpp.

                                                        {
    JSArray cmds = emscripten::val::array();
    for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
        JSArray cmd = emscripten::val::array();
        switch (verb) {
        case SkPathVerb::kMove:
            cmd.call<void>("push", MOVE, pts[0].x(), pts[0].y());
            break;
        case SkPathVerb::kLine:
            cmd.call<void>("push", LINE, pts[1].x(), pts[1].y());
            break;
        case SkPathVerb::kQuad:
            cmd.call<void>("push", QUAD, pts[1].x(), pts[1].y(), pts[2].x(), pts[2].y());
            break;
        case SkPathVerb::kConic:
            cmd.call<void>("push", CONIC,
                           pts[1].x(), pts[1].y(),
                           pts[2].x(), pts[2].y(), *w);
            break;
        case SkPathVerb::kCubic:
            cmd.call<void>("push", CUBIC,
                           pts[1].x(), pts[1].y(),
                           pts[2].x(), pts[2].y(),
                           pts[3].x(), pts[3].y());
            break;
        case SkPathVerb::kClose:
            cmd.call<void>("push", CLOSE);
            break;
        }
        cmds.call<void>("push", cmd);
    }
    return cmds;
}

ToPath2D()

emscripten::val EMSCRIPTEN_KEEPALIVE ToPath2D

(

const SkPath &

path

)

Definition at line 307 of file pathkit_wasm_bindings.cpp.

                                                                {
    emscripten::val retVal = JSPath2D.new_();
    ToCanvas(path, retVal);
    return retVal;
}

toSkMatrix()

SkMatrix toSkMatrix

(

const SimpleMatrix &

sm

)

Definition at line 439 of file pathkit_wasm_bindings.cpp.

                                            {
    return SkMatrix::MakeAll(sm.scaleX, sm.skewX , sm.transX,
                             sm.skewY , sm.scaleY, sm.transY,
                             sm.pers0 , sm.pers1 , sm.pers2);
}

ToSVGString()

JSString EMSCRIPTEN_KEEPALIVE ToSVGString

(

const SkPath &

path

)

Definition at line 217 of file pathkit_wasm_bindings.cpp.

                                                              {
    // Wrapping it in val automatically turns it into a JS string.
    // Not too sure on performance implications, but is is simpler than
    // returning a raw pointer to const char * and then using
    // UTF8ToString() on the calling side.
    return emscripten::val(SkParsePath::ToSVGString(path).c_str());
}

Variable Documentation

CLOSE

const int CLOSE = 5

static

Definition at line 36 of file pathkit_wasm_bindings.cpp.

CONIC

const int CONIC = 3

static

Definition at line 34 of file pathkit_wasm_bindings.cpp.

CUBIC

const int CUBIC = 4

static

Definition at line 35 of file pathkit_wasm_bindings.cpp.

JSPath2D

emscripten::val JSPath2D = emscripten::val::global("Path2D")

Definition at line 305 of file pathkit_wasm_bindings.cpp.

LINE

const int LINE = 1

static

Definition at line 32 of file pathkit_wasm_bindings.cpp.

MOVE

const int MOVE = 0

static

Definition at line 31 of file pathkit_wasm_bindings.cpp.

QUAD

const int QUAD = 2

static

Definition at line 33 of file pathkit_wasm_bindings.cpp.