1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkPathOpsConic_DEFINED
#define SkPathOpsConic_DEFINED
#include "SkPathOpsPoint.h"
#include "SkPathOpsQuad.h"
struct SkDConic {
static const int kPointCount = 3;
static const int kPointLast = kPointCount - 1;
static const int kMaxIntersections = 4;
SkDQuad fPts;
SkScalar fWeight;
bool collapsed() const {
return fPts.collapsed();
}
bool controlsInside() const {
return fPts.controlsInside();
}
void debugInit() {
fPts.debugInit();
}
void debugSet(const SkDPoint* pts, SkScalar weight);
SkDConic flip() const {
SkDConic result = {{{fPts[2], fPts[1], fPts[0]}
SkDEBUGPARAMS(fPts.fDebugGlobalState) }, fWeight};
return result;
}
#ifdef SK_DEBUG
SkOpGlobalState* globalState() const { return fPts.globalState(); }
#endif
static bool IsConic() { return true; }
const SkDConic& set(const SkPoint pts[kPointCount], SkScalar weight
SkDEBUGPARAMS(SkOpGlobalState* state = nullptr)) {
fPts.set(pts SkDEBUGPARAMS(state));
fWeight = weight;
return *this;
}
const SkDPoint& operator[](int n) const { return fPts[n]; }
SkDPoint& operator[](int n) { return fPts[n]; }
static int AddValidTs(double s[], int realRoots, double* t) {
return SkDQuad::AddValidTs(s, realRoots, t);
}
void align(int endIndex, SkDPoint* dstPt) const {
fPts.align(endIndex, dstPt);
}
SkDVector dxdyAtT(double t) const;
static int FindExtrema(const double src[], SkScalar weight, double tValue[1]);
bool hullIntersects(const SkDQuad& quad, bool* isLinear) const {
return fPts.hullIntersects(quad, isLinear);
}
bool hullIntersects(const SkDConic& conic, bool* isLinear) const {
return fPts.hullIntersects(conic.fPts, isLinear);
}
bool hullIntersects(const SkDCubic& cubic, bool* isLinear) const;
bool isLinear(int startIndex, int endIndex) const {
return fPts.isLinear(startIndex, endIndex);
}
bool monotonicInX() const {
return fPts.monotonicInX();
}
bool monotonicInY() const {
return fPts.monotonicInY();
}
void otherPts(int oddMan, const SkDPoint* endPt[2]) const {
fPts.otherPts(oddMan, endPt);
}
SkDPoint ptAtT(double t) const;
static int RootsReal(double A, double B, double C, double t[2]) {
return SkDQuad::RootsReal(A, B, C, t);
}
static int RootsValidT(const double A, const double B, const double C, double s[2]) {
return SkDQuad::RootsValidT(A, B, C, s);
}
SkDConic subDivide(double t1, double t2) const;
static SkDConic SubDivide(const SkPoint a[kPointCount], SkScalar weight, double t1, double t2) {
SkDConic conic;
conic.set(a, weight);
return conic.subDivide(t1, t2);
}
SkDPoint subDivide(const SkDPoint& a, const SkDPoint& c, double t1, double t2,
SkScalar* weight) const;
static SkDPoint SubDivide(const SkPoint pts[kPointCount], SkScalar weight,
const SkDPoint& a, const SkDPoint& c,
double t1, double t2, SkScalar* newWeight) {
SkDConic conic;
conic.set(pts, weight);
return conic.subDivide(a, c, t1, t2, newWeight);
}
// utilities callable by the user from the debugger when the implementation code is linked in
void dump() const;
void dumpID(int id) const;
void dumpInner() const;
};
#endif
|
