SkPathOpsCurve.h | Explore in Territory

/*
 * Copyright 2012 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
#ifndef SkPathOpsCurve_DEFINE
#define SkPathOpsCurve_DEFINE

#include "include/core/SkPath.h"
#include "include/core/SkPoint.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkDebug.h"
#include "src/pathops/SkIntersections.h"
#include "src/pathops/SkPathOpsConic.h"
#include "src/pathops/SkPathOpsCubic.h"
#include "src/pathops/SkPathOpsLine.h"
#include "src/pathops/SkPathOpsPoint.h"
#include "src/pathops/SkPathOpsQuad.h"
#include "src/pathops/SkPathOpsTypes.h"

struct SkPathOpsBounds;

struct SkOpCurve { … };

struct SkDCurve { … };

class SkDCurveSweep { … };

extern SkDPoint (SkDCurve::* const Top[])(const SkPoint curve[], SkScalar cWeight,
    double tStart, double tEnd, double* topT);

static SkDPoint dline_xy_at_t(const SkPoint a[2], SkScalar , double t) { … }

static SkDPoint dquad_xy_at_t(const SkPoint a[3], SkScalar , double t) { … }

static SkDPoint dconic_xy_at_t(const SkPoint a[3], SkScalar weight, double t) { … }

static SkDPoint dcubic_xy_at_t(const SkPoint a[4], SkScalar , double t) { … }

static SkDPoint (* const CurveDPointAtT[])(const SkPoint[], SkScalar , double ) = …;

static SkDPoint ddline_xy_at_t(const SkDCurve& c, double t) { … }

static SkDPoint ddquad_xy_at_t(const SkDCurve& c, double t) { … }

static SkDPoint ddconic_xy_at_t(const SkDCurve& c, double t) { … }

static SkDPoint ddcubic_xy_at_t(const SkDCurve& c, double t) { … }

static SkDPoint (* const CurveDDPointAtT[])(const SkDCurve& , double ) = …;

static SkPoint fline_xy_at_t(const SkPoint a[2], SkScalar weight, double t) { … }

static SkPoint fquad_xy_at_t(const SkPoint a[3], SkScalar weight, double t) { … }

static SkPoint fconic_xy_at_t(const SkPoint a[3], SkScalar weight, double t) { … }

static SkPoint fcubic_xy_at_t(const SkPoint a[4], SkScalar weight, double t) { … }

static SkPoint (* const CurvePointAtT[])(const SkPoint[], SkScalar , double ) = …;

static SkDVector dline_dxdy_at_t(const SkPoint a[2], SkScalar , double ) { … }

static SkDVector dquad_dxdy_at_t(const SkPoint a[3], SkScalar , double t) { … }

static SkDVector dconic_dxdy_at_t(const SkPoint a[3], SkScalar weight, double t) { … }

static SkDVector dcubic_dxdy_at_t(const SkPoint a[4], SkScalar , double t) { … }

static SkDVector (* const CurveDSlopeAtT[])(const SkPoint[], SkScalar , double ) = …;

static SkDVector ddline_dxdy_at_t(const SkDCurve& c, double ) { … }

static SkDVector ddquad_dxdy_at_t(const SkDCurve& c, double t) { … }

static SkDVector ddconic_dxdy_at_t(const SkDCurve& c, double t) { … }

static SkDVector ddcubic_dxdy_at_t(const SkDCurve& c, double t) { … }

static SkDVector (* const CurveDDSlopeAtT[])(const SkDCurve& , double ) = …;

static SkVector fline_dxdy_at_t(const SkPoint a[2], SkScalar , double ) { … }

static SkVector fquad_dxdy_at_t(const SkPoint a[3], SkScalar weight, double t) { … }

static SkVector fconic_dxdy_at_t(const SkPoint a[3], SkScalar weight, double t) { … }

static SkVector fcubic_dxdy_at_t(const SkPoint a[4], SkScalar weight, double t) { … }

static SkVector (* const CurveSlopeAtT[])(const SkPoint[], SkScalar , double ) = …;

static bool line_is_vertical(const SkPoint a[2], SkScalar , double startT, double endT) { … }

static bool quad_is_vertical(const SkPoint a[3], SkScalar , double startT, double endT) { … }

static bool conic_is_vertical(const SkPoint a[3], SkScalar weight, double startT, double endT) { … }

static bool cubic_is_vertical(const SkPoint a[4], SkScalar , double startT, double endT) { … }

static bool (* const CurveIsVertical[])(const SkPoint[], SkScalar , double , double) = …;

static void line_intersect_ray(const SkPoint a[2], SkScalar , const SkDLine& ray,
        SkIntersections* i) { … }

static void quad_intersect_ray(const SkPoint a[3], SkScalar , const SkDLine& ray,
        SkIntersections* i) { … }

static void conic_intersect_ray(const SkPoint a[3], SkScalar weight, const SkDLine& ray,
        SkIntersections* i) { … }

static void cubic_intersect_ray(const SkPoint a[4], SkScalar , const SkDLine& ray,
        SkIntersections* i) { … }

static void (* const CurveIntersectRay[])(const SkPoint[] , SkScalar , const SkDLine& ,
        SkIntersections* ) = …;

static void dline_intersect_ray(const SkDCurve& c, const SkDLine& ray,  SkIntersections* i) { … }

static void dquad_intersect_ray(const SkDCurve& c, const SkDLine& ray, SkIntersections* i) { … }

static void dconic_intersect_ray(const SkDCurve& c, const SkDLine& ray, SkIntersections* i) { … }

static void dcubic_intersect_ray(const SkDCurve& c, const SkDLine& ray, SkIntersections* i) { … }

static void (* const CurveDIntersectRay[])(const SkDCurve& , const SkDLine& , SkIntersections* ) = …;

static int line_intercept_h(const SkPoint a[2], SkScalar , SkScalar y, double* roots) { … }

static int line_intercept_v(const SkPoint a[2], SkScalar , SkScalar x, double* roots) { … }

static int quad_intercept_h(const SkPoint a[2], SkScalar , SkScalar y, double* roots) { … }

static int quad_intercept_v(const SkPoint a[2], SkScalar , SkScalar x, double* roots) { … }

static int conic_intercept_h(const SkPoint a[2], SkScalar w, SkScalar y, double* roots) { … }

static int conic_intercept_v(const SkPoint a[2], SkScalar w, SkScalar x, double* roots) { … }

static int cubic_intercept_h(const SkPoint a[3], SkScalar , SkScalar y, double* roots) { … }

static int cubic_intercept_v(const SkPoint a[3], SkScalar , SkScalar x, double* roots) { … }

static int (* const CurveIntercept[])(const SkPoint[] , SkScalar , SkScalar , double* ) = …;

#endif
chromium/third_party/skia/src/pathops/SkPathOpsCurve.h
