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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "sk_types_priv.h"
#include "SkMatrix.h"
static void from_c_matrix(const sk_matrix_t* cmatrix, SkMatrix* matrix) {
matrix->setAll(cmatrix->mat[0], cmatrix->mat[1], cmatrix->mat[2],
cmatrix->mat[3], cmatrix->mat[4], cmatrix->mat[5],
cmatrix->mat[6], cmatrix->mat[7], cmatrix->mat[8]);
}
#include "../../include/effects/SkGradientShader.h"
#include "sk_shader.h"
const struct {
sk_shader_tilemode_t fC;
SkShader::TileMode fSK;
} gTileModeMap[] = {
{ CLAMP_SK_SHADER_TILEMODE, SkShader::kClamp_TileMode },
{ REPEAT_SK_SHADER_TILEMODE, SkShader::kRepeat_TileMode },
{ MIRROR_SK_SHADER_TILEMODE, SkShader::kMirror_TileMode },
};
static bool from_c_tilemode(sk_shader_tilemode_t cMode, SkShader::TileMode* skMode) {
for (size_t i = 0; i < SK_ARRAY_COUNT(gTileModeMap); ++i) {
if (cMode == gTileModeMap[i].fC) {
if (skMode) {
*skMode = gTileModeMap[i].fSK;
}
return true;
}
}
return false;
}
void sk_shader_ref(sk_shader_t* cshader) {
SkSafeRef(AsShader(cshader));
}
void sk_shader_unref(sk_shader_t* cshader) {
SkSafeUnref(AsShader(cshader));
}
sk_shader_t* sk_shader_new_linear_gradient(const sk_point_t pts[2],
const sk_color_t colors[],
const float colorPos[],
int colorCount,
sk_shader_tilemode_t cmode,
const sk_matrix_t* cmatrix) {
SkShader::TileMode mode;
if (!from_c_tilemode(cmode, &mode)) {
return nullptr;
}
SkMatrix matrix;
if (cmatrix) {
from_c_matrix(cmatrix, &matrix);
} else {
matrix.setIdentity();
}
return (sk_shader_t*)SkGradientShader::MakeLinear(reinterpret_cast<const SkPoint*>(pts),
reinterpret_cast<const SkColor*>(colors),
colorPos, colorCount,
mode, 0, &matrix).release();
}
static const SkPoint& to_skpoint(const sk_point_t& p) {
return reinterpret_cast<const SkPoint&>(p);
}
sk_shader_t* sk_shader_new_radial_gradient(const sk_point_t* ccenter,
float radius,
const sk_color_t colors[],
const float colorPos[],
int colorCount,
sk_shader_tilemode_t cmode,
const sk_matrix_t* cmatrix) {
SkShader::TileMode mode;
if (!from_c_tilemode(cmode, &mode)) {
return nullptr;
}
SkMatrix matrix;
if (cmatrix) {
from_c_matrix(cmatrix, &matrix);
} else {
matrix.setIdentity();
}
SkPoint center = to_skpoint(*ccenter);
return (sk_shader_t*)SkGradientShader::MakeRadial(center, (SkScalar)radius,
reinterpret_cast<const SkColor*>(colors),
reinterpret_cast<const SkScalar*>(colorPos),
colorCount, mode, 0, &matrix).release();
}
sk_shader_t* sk_shader_new_sweep_gradient(const sk_point_t* ccenter,
const sk_color_t colors[],
const float colorPos[],
int colorCount,
const sk_matrix_t* cmatrix) {
SkMatrix matrix;
if (cmatrix) {
from_c_matrix(cmatrix, &matrix);
} else {
matrix.setIdentity();
}
return (sk_shader_t*)SkGradientShader::MakeSweep((SkScalar)(ccenter->x),
(SkScalar)(ccenter->y),
reinterpret_cast<const SkColor*>(colors),
reinterpret_cast<const SkScalar*>(colorPos),
colorCount, 0, &matrix).release();
}
sk_shader_t* sk_shader_new_two_point_conical_gradient(const sk_point_t* start,
float startRadius,
const sk_point_t* end,
float endRadius,
const sk_color_t colors[],
const float colorPos[],
int colorCount,
sk_shader_tilemode_t cmode,
const sk_matrix_t* cmatrix) {
SkShader::TileMode mode;
if (!from_c_tilemode(cmode, &mode)) {
return nullptr;
}
SkMatrix matrix;
if (cmatrix) {
from_c_matrix(cmatrix, &matrix);
} else {
matrix.setIdentity();
}
SkPoint skstart = to_skpoint(*start);
SkPoint skend = to_skpoint(*end);
return (sk_shader_t*)SkGradientShader::MakeTwoPointConical(skstart, (SkScalar)startRadius,
skend, (SkScalar)endRadius,
reinterpret_cast<const SkColor*>(colors),
reinterpret_cast<const SkScalar*>(colorPos),
colorCount, mode, 0, &matrix).release();
}
///////////////////////////////////////////////////////////////////////////////////////////
#include "sk_maskfilter.h"
#include "SkMaskFilter.h"
const struct {
sk_blurstyle_t fC;
SkBlurStyle fSk;
} gBlurStylePairs[] = {
{ NORMAL_SK_BLUR_STYLE, kNormal_SkBlurStyle },
{ SOLID_SK_BLUR_STYLE, kSolid_SkBlurStyle },
{ OUTER_SK_BLUR_STYLE, kOuter_SkBlurStyle },
{ INNER_SK_BLUR_STYLE, kInner_SkBlurStyle },
};
static bool find_blurstyle(sk_blurstyle_t csrc, SkBlurStyle* dst) {
for (size_t i = 0; i < SK_ARRAY_COUNT(gBlurStylePairs); ++i) {
if (gBlurStylePairs[i].fC == csrc) {
if (dst) {
*dst = gBlurStylePairs[i].fSk;
}
return true;
}
}
return false;
}
void sk_maskfilter_ref(sk_maskfilter_t* cfilter) {
SkSafeRef(AsMaskFilter(cfilter));
}
void sk_maskfilter_unref(sk_maskfilter_t* cfilter) {
SkSafeUnref(AsMaskFilter(cfilter));
}
sk_maskfilter_t* sk_maskfilter_new_blur(sk_blurstyle_t cstyle, float sigma) {
SkBlurStyle style;
if (!find_blurstyle(cstyle, &style)) {
return nullptr;
}
return ToMaskFilter(SkMaskFilter::MakeBlur(style, sigma).release());
}
|
