sk_effects.cpp revision d678723728780c8ed75b1fad56a921ea39ee8325
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 "sk_types_priv.h" 9#include "SkMatrix.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/effects/SkGradientShader.h" 18#include "sk_shader.h" 19 20const struct { 21 sk_shader_tilemode_t fC; 22 SkShader::TileMode fSK; 23} gTileModeMap[] = { 24 { CLAMP_SK_SHADER_TILEMODE, SkShader::kClamp_TileMode }, 25 { REPEAT_SK_SHADER_TILEMODE, SkShader::kRepeat_TileMode }, 26 { MIRROR_SK_SHADER_TILEMODE, SkShader::kMirror_TileMode }, 27}; 28 29static bool from_c_tilemode(sk_shader_tilemode_t cMode, SkShader::TileMode* 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 SkShader::TileMode mode; 56 if (!from_c_tilemode(cmode, &mode)) { 57 return NULL; 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 SkShader::TileMode mode; 83 if (!from_c_tilemode(cmode, &mode)) { 84 return NULL; 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 SkShader::TileMode mode; 127 if (!from_c_tilemode(cmode, &mode)) { 128 return NULL; 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/effects/SkBlurMaskFilter.h" 148#include "sk_maskfilter.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 NULL; 184 } 185 return ToMaskFilter(SkBlurMaskFilter::Make(style, sigma).release()); 186} 187