sk_effects.cpp 7.0 KB

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