src/c/sk_shader.cpp

   1 /*
   2  * Copyright 2014 Google Inc.
   3  * Copyright 2015 Xamarin Inc.
   4  * Copyright 2017 Microsoft Corporation. All rights reserved.
   5  *
   6  * Use of this source code is governed by a BSD-style license that can be
   7  * found in the LICENSE file.
   8  */
   9
  10 #include "SkShader.h"
  11 #include "SkComposeShader.h"
  12 #include "SkColorFilter.h"
  13 #include "SkGradientShader.h"
  14 #include "SkPerlinNoiseShader.h"
  15
  16 #include "sk_shader.h"
  17
  18 #include "sk_types_priv.h"
  19
  20 sk_shader_t* sk_shader_new_empty() {
  21     return ToShader(SkShader::MakeEmptyShader().release());
  22 }
  23
  24 sk_shader_t* sk_shader_new_color(sk_color_t color) {
  25     return ToShader(SkShader::MakeColorShader(color).release());
  26 }
  27
  28 sk_shader_t* sk_shader_new_bitmap(const sk_bitmap_t* src,
  29                                   sk_shader_tilemode_t tmx,
  30                                   sk_shader_tilemode_t tmy,
  31                                   const sk_matrix_t* localMatrix) {
  32     SkMatrix matrix;
  33     if (localMatrix) {
  34         from_c(localMatrix, &matrix);
  35     } else {
  36         matrix.setIdentity();
  37     }
  38     sk_sp<SkShader> s = SkShader::MakeBitmapShader(
  39         *AsBitmap(src),
  40         (SkShader::TileMode)tmx,
  41         (SkShader::TileMode)tmy,
  42         &matrix);
  43     return ToShader(s.release());
  44 }
  45
  46 sk_shader_t* sk_shader_new_picture(sk_picture_t* src,
  47                                   sk_shader_tilemode_t tmx,
  48                                   sk_shader_tilemode_t tmy,
  49                                   const sk_matrix_t* localMatrix,
  50                                   const sk_rect_t* tile) {
  51     SkMatrix matrix;
  52     if (localMatrix) {
  53         from_c(localMatrix, &matrix);
  54     }
  55     else {
  56         matrix.setIdentity();
  57     }
  58     sk_sp<SkShader> s = SkShader::MakePictureShader(
  59         sk_ref_sp(AsPicture(src)),
  60         (SkShader::TileMode)tmx,
  61         (SkShader::TileMode)tmy,
  62         &matrix,
  63         AsRect(tile));
  64     return ToShader(s.release());
  65 }
  66
  67 sk_shader_t* sk_shader_new_color_filter(sk_shader_t* proxy,
  68                                         sk_colorfilter_t* filter) {
  69     sk_sp<SkShader> s = AsShader(proxy)->makeWithColorFilter(sk_ref_sp(AsColorFilter(filter)));
  70     return ToShader(s.release());
  71 }
  72
  73 sk_shader_t* sk_shader_new_local_matrix(sk_shader_t* proxy,
  74                                         const sk_matrix_t* localMatrix) {
  75     SkMatrix matrix;
  76     if (localMatrix) {
  77         from_c(localMatrix, &matrix);
  78     } else {
  79         matrix.setIdentity();
  80     }
  81     sk_sp<SkShader> s = AsShader(proxy)->makeWithLocalMatrix(matrix);
  82     return ToShader(s.release());
  83 }
  84
  85 sk_shader_t* sk_shader_new_perlin_noise_fractal_noise(
  86     float baseFrequencyX,
  87     float baseFrequencyY,
  88     int numOctaves,
  89     float seed,
  90     const sk_isize_t* ctileSize) {
  91
  92     const SkISize* tileSize = AsISize(ctileSize);
  93     sk_sp<SkShader> s = SkPerlinNoiseShader::MakeFractalNoise(
  94         baseFrequencyX,
  95         baseFrequencyY,
  96         numOctaves,
  97         seed,
  98         tileSize);
  99     return ToShader(s.release());
 100 }
 101
 102 sk_shader_t* sk_shader_new_perlin_noise_turbulence(
 103     float baseFrequencyX,
 104     float baseFrequencyY,
 105     int numOctaves,
 106     float seed,
 107     const sk_isize_t* ctileSize) {
 108
 109     const SkISize* tileSize = AsISize(ctileSize);
 110     sk_sp<SkShader> s = SkPerlinNoiseShader::MakeTurbulence(
 111         baseFrequencyX,
 112         baseFrequencyY,
 113         numOctaves,
 114         seed,
 115         tileSize);
 116     return ToShader(s.release());
 117 }
 118
 119 sk_shader_t* sk_shader_new_compose(
 120     sk_shader_t* shaderA,
 121     sk_shader_t* shaderB) {
 122
 123     sk_sp<SkShader> s = SkShader::MakeComposeShader(
 124         sk_ref_sp(AsShader(shaderA)),
 125         sk_ref_sp(AsShader(shaderB)),
 126         SkBlendMode::kSrcOver);
 127     return ToShader(s.release());
 128 }
 129
 130 sk_shader_t* sk_shader_new_compose_with_mode(
 131     sk_shader_t* shaderA,
 132     sk_shader_t* shaderB,
 133     sk_blendmode_t cmode) {
 134
 135     sk_sp<SkShader> s = SkShader::MakeComposeShader(
 136         sk_ref_sp(AsShader(shaderA)),
 137         sk_ref_sp(AsShader(shaderB)),
 138         (SkBlendMode)cmode);
 139     return ToShader(s.release());
 140 }
 141
 142 void sk_shader_ref(sk_shader_t* cshader) {
 143     SkSafeRef(AsShader(cshader));
 144 }
 145
 146 void sk_shader_unref(sk_shader_t* cshader) {
 147     SkSafeUnref(AsShader(cshader));
 148 }
 149
 150 sk_shader_t* sk_shader_new_linear_gradient(const sk_point_t pts[2],
 151                                            const sk_color_t colors[],
 152                                            const float colorPos[],
 153                                            int colorCount,
 154                                            sk_shader_tilemode_t cmode,
 155                                            const sk_matrix_t* cmatrix) {
 156     SkMatrix matrix;
 157     if (cmatrix) {
 158         from_c(cmatrix, &matrix);
 159     } else {
 160         matrix.setIdentity();
 161     }
 162     return (sk_shader_t*)SkGradientShader::MakeLinear(reinterpret_cast<const SkPoint*>(pts),
 163                                                       reinterpret_cast<const SkColor*>(colors),
 164                                                       colorPos, colorCount,
 165                                                       (SkShader::TileMode)cmode, 0, &matrix).release();
 166 }
 167
 168 sk_shader_t* sk_shader_new_radial_gradient(const sk_point_t* ccenter,
 169                                            float radius,
 170                                            const sk_color_t colors[],
 171                                            const float colorPos[],
 172                                            int colorCount,
 173                                            sk_shader_tilemode_t cmode,
 174                                            const sk_matrix_t* cmatrix) {
 175     SkMatrix matrix;
 176     if (cmatrix) {
 177         from_c(cmatrix, &matrix);
 178     } else {
 179         matrix.setIdentity();
 180     }
 181     SkPoint center = AsPoint(*ccenter);
 182     return (sk_shader_t*)SkGradientShader::MakeRadial(center, (SkScalar)radius,
 183                                                       reinterpret_cast<const SkColor*>(colors),
 184                                                       reinterpret_cast<const SkScalar*>(colorPos),
 185                                                       colorCount, (SkShader::TileMode)cmode, 0, &matrix).release();
 186 }
 187
 188 sk_shader_t* sk_shader_new_sweep_gradient(const sk_point_t* ccenter,
 189                                           const sk_color_t colors[],
 190                                           const float colorPos[],
 191                                           int colorCount,
 192                                           const sk_matrix_t* cmatrix) {
 193     SkMatrix matrix;
 194     if (cmatrix) {
 195         from_c(cmatrix, &matrix);
 196     } else {
 197         matrix.setIdentity();
 198     }
 199     return (sk_shader_t*)SkGradientShader::MakeSweep((SkScalar)(ccenter->x),
 200                                                      (SkScalar)(ccenter->y),
 201                                                      reinterpret_cast<const SkColor*>(colors),
 202                                                      reinterpret_cast<const SkScalar*>(colorPos),
 203                                                      colorCount, 0, &matrix).release();
 204 }
 205
 206 sk_shader_t* sk_shader_new_two_point_conical_gradient(const sk_point_t* start,
 207                                                       float startRadius,
 208                                                       const sk_point_t* end,
 209                                                       float endRadius,
 210                                                       const sk_color_t colors[],
 211                                                       const float colorPos[],
 212                                                       int colorCount,
 213                                                       sk_shader_tilemode_t cmode,
 214                                                       const sk_matrix_t* cmatrix) {
 215     SkMatrix matrix;
 216     if (cmatrix) {
 217         from_c(cmatrix, &matrix);
 218     } else {
 219         matrix.setIdentity();
 220     }
 221     SkPoint skstart = AsPoint(*start);
 222     SkPoint skend = AsPoint(*end);
 223     return (sk_shader_t*)SkGradientShader::MakeTwoPointConical(skstart, (SkScalar)startRadius,
 224                                                         skend, (SkScalar)endRadius,
 225                                                         reinterpret_cast<const SkColor*>(colors),
 226                                                         reinterpret_cast<const SkScalar*>(colorPos),
 227                                                         colorCount, (SkShader::TileMode)cmode, 0, &matrix).release();
 228 }