1/*
2 * Copyright 2017 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "include/core/SkMatrix.h"
9#include "src/c/sk_types_priv.h"
10
11static void from_c_matrix(const sk_matrix_t* cmatrix, SkMatrix* matrix) {
12 matrix->setAll(cmatrix->mat[0], cmatrix->mat[1], cmatrix->mat[2],
13 cmatrix->mat[3], cmatrix->mat[4], cmatrix->mat[5],
14 cmatrix->mat[6], cmatrix->mat[7], cmatrix->mat[8]);
15}
16
17#include "include/c/sk_shader.h"
18#include "include/effects/SkGradientShader.h"
19
20const struct {
21 sk_shader_tilemode_t fC;
22 SkTileMode fSK;
23} gTileModeMap[] = {
24 { CLAMP_SK_SHADER_TILEMODE, SkTileMode::kClamp },
25 { REPEAT_SK_SHADER_TILEMODE, SkTileMode::kRepeat },
26 { MIRROR_SK_SHADER_TILEMODE, SkTileMode::kMirror },
27};
28
29static bool from_c_tilemode(sk_shader_tilemode_t cMode, SkTileMode* skMode) {
30 for (size_t i = 0; i < SK_ARRAY_COUNT(gTileModeMap); ++i) {
31 if (cMode == gTileModeMap[i].fC) {
32 if (skMode) {
33 *skMode = gTileModeMap[i].fSK;
34 }
35 return true;
36 }
37 }
38 return false;
39}
40
41void sk_shader_ref(sk_shader_t* cshader) {
42 SkSafeRef(AsShader(cshader));
43}
44
45void sk_shader_unref(sk_shader_t* cshader) {
46 SkSafeUnref(AsShader(cshader));
47}
48
49sk_shader_t* sk_shader_new_linear_gradient(const sk_point_t pts[2],
50 const sk_color_t colors[],
51 const float colorPos[],
52 int colorCount,
53 sk_shader_tilemode_t cmode,
54 const sk_matrix_t* cmatrix) {
55 SkTileMode mode;
56 if (!from_c_tilemode(cmode, &mode)) {
57 return nullptr;
58 }
59 SkMatrix matrix;
60 if (cmatrix) {
61 from_c_matrix(cmatrix, &matrix);
62 } else {
63 matrix.setIdentity();
64 }
65 return (sk_shader_t*)SkGradientShader::MakeLinear(reinterpret_cast<const SkPoint*>(pts),
66 reinterpret_cast<const SkColor*>(colors),
67 colorPos, colorCount,
68 mode, 0, &matrix).release();
69}
70
71static const SkPoint& to_skpoint(const sk_point_t& p) {
72 return reinterpret_cast<const SkPoint&>(p);
73}
74
75sk_shader_t* sk_shader_new_radial_gradient(const sk_point_t* ccenter,
76 float radius,
77 const sk_color_t colors[],
78 const float colorPos[],
79 int colorCount,
80 sk_shader_tilemode_t cmode,
81 const sk_matrix_t* cmatrix) {
82 SkTileMode mode;
83 if (!from_c_tilemode(cmode, &mode)) {
84 return nullptr;
85 }
86 SkMatrix matrix;
87 if (cmatrix) {
88 from_c_matrix(cmatrix, &matrix);
89 } else {
90 matrix.setIdentity();
91 }
92 SkPoint center = to_skpoint(*ccenter);
93 return (sk_shader_t*)SkGradientShader::MakeRadial(center, (SkScalar)radius,
94 reinterpret_cast<const SkColor*>(colors),
95 reinterpret_cast<const SkScalar*>(colorPos),
96 colorCount, mode, 0, &matrix).release();
97}
98
99sk_shader_t* sk_shader_new_sweep_gradient(const sk_point_t* ccenter,
100 const sk_color_t colors[],
101 const float colorPos[],
102 int colorCount,
103 const sk_matrix_t* cmatrix) {
104 SkMatrix matrix;
105 if (cmatrix) {
106 from_c_matrix(cmatrix, &matrix);
107 } else {
108 matrix.setIdentity();
109 }
110 return (sk_shader_t*)SkGradientShader::MakeSweep((SkScalar)(ccenter->x),
111 (SkScalar)(ccenter->y),
112 reinterpret_cast<const SkColor*>(colors),
113 reinterpret_cast<const SkScalar*>(colorPos),
114 colorCount, 0, &matrix).release();
115}
116
117sk_shader_t* sk_shader_new_two_point_conical_gradient(const sk_point_t* start,
118 float startRadius,
119 const sk_point_t* end,
120 float endRadius,
121 const sk_color_t colors[],
122 const float colorPos[],
123 int colorCount,
124 sk_shader_tilemode_t cmode,
125 const sk_matrix_t* cmatrix) {
126 SkTileMode mode;
127 if (!from_c_tilemode(cmode, &mode)) {
128 return nullptr;
129 }
130 SkMatrix matrix;
131 if (cmatrix) {
132 from_c_matrix(cmatrix, &matrix);
133 } else {
134 matrix.setIdentity();
135 }
136 SkPoint skstart = to_skpoint(*start);
137 SkPoint skend = to_skpoint(*end);
138 return (sk_shader_t*)SkGradientShader::MakeTwoPointConical(skstart, (SkScalar)startRadius,
139 skend, (SkScalar)endRadius,
140 reinterpret_cast<const SkColor*>(colors),
141 reinterpret_cast<const SkScalar*>(colorPos),
142 colorCount, mode, 0, &matrix).release();
143}
144
145///////////////////////////////////////////////////////////////////////////////////////////
146
147#include "include/c/sk_maskfilter.h"
148#include "include/core/SkMaskFilter.h"
149
150const struct {
151 sk_blurstyle_t fC;
152 SkBlurStyle fSk;
153} gBlurStylePairs[] = {
154 { NORMAL_SK_BLUR_STYLE, kNormal_SkBlurStyle },
155 { SOLID_SK_BLUR_STYLE, kSolid_SkBlurStyle },
156 { OUTER_SK_BLUR_STYLE, kOuter_SkBlurStyle },
157 { INNER_SK_BLUR_STYLE, kInner_SkBlurStyle },
158};
159
160static bool find_blurstyle(sk_blurstyle_t csrc, SkBlurStyle* dst) {
161 for (size_t i = 0; i < SK_ARRAY_COUNT(gBlurStylePairs); ++i) {
162 if (gBlurStylePairs[i].fC == csrc) {
163 if (dst) {
164 *dst = gBlurStylePairs[i].fSk;
165 }
166 return true;
167 }
168 }
169 return false;
170}
171
172void sk_maskfilter_ref(sk_maskfilter_t* cfilter) {
173 SkSafeRef(AsMaskFilter(cfilter));
174}
175
176void sk_maskfilter_unref(sk_maskfilter_t* cfilter) {
177 SkSafeUnref(AsMaskFilter(cfilter));
178}
179
180sk_maskfilter_t* sk_maskfilter_new_blur(sk_blurstyle_t cstyle, float sigma) {
181 SkBlurStyle style;
182 if (!find_blurstyle(cstyle, &style)) {
183 return nullptr;
184 }
185 return ToMaskFilter(SkMaskFilter::MakeBlur(style, sigma).release());
186}
187