| /* |
| * Copyright 2025 Google LLC. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #ifndef SkGradient_DEFINED |
| #define SkGradient_DEFINED |
| |
| #include "include/core/SkColor.h" |
| #include "include/core/SkColorSpace.h" |
| #include "include/core/SkPoint.h" |
| #include "include/core/SkShader.h" |
| #include "include/core/SkSpan.h" |
| #include "include/core/SkTileMode.h" |
| #include "include/private/base/SkAPI.h" |
| |
| class SkMatrix; |
| |
| class SkGradient { |
| public: |
| struct Interpolation { |
| enum class InPremul : bool { kNo = false, kYes = true }; |
| |
| enum class ColorSpace : uint8_t { |
| // Default Skia behavior: interpolate in the color space of the destination surface |
| kDestination, |
| |
| // https://www.w3.org/TR/css-color-4/#interpolation-space |
| kSRGBLinear, |
| kLab, |
| kOKLab, |
| // This is the same as kOKLab, except it has a simplified version of the CSS gamut |
| // mapping algorithm (https://www.w3.org/TR/css-color-4/#css-gamut-mapping) |
| // into Rec2020 space applied to it. |
| // Warning: This space is experimental and should not be used in production. |
| kOKLabGamutMap, |
| kLCH, |
| kOKLCH, |
| // This is the same as kOKLCH, except it has the same gamut mapping applied to it |
| // as kOKLabGamutMap does. |
| // Warning: This space is experimental and should not be used in production. |
| kOKLCHGamutMap, |
| kSRGB, |
| kHSL, |
| kHWB, |
| |
| kDisplayP3, |
| kRec2020, |
| kProphotoRGB, |
| kA98RGB, |
| |
| kLastColorSpace = kA98RGB, |
| }; |
| static constexpr int kColorSpaceCount = static_cast<int>(ColorSpace::kLastColorSpace) + 1; |
| |
| enum class HueMethod : uint8_t { |
| // https://www.w3.org/TR/css-color-4/#hue-interpolation |
| kShorter, |
| kLonger, |
| kIncreasing, |
| kDecreasing, |
| |
| kLastHueMethod = kDecreasing, |
| }; |
| static constexpr int kHueMethodCount = static_cast<int>(HueMethod::kLastHueMethod) + 1; |
| |
| InPremul fInPremul = InPremul::kNo; |
| ColorSpace fColorSpace = ColorSpace::kDestination; |
| HueMethod fHueMethod = HueMethod::kShorter; // Only relevant for LCH, OKLCH, HSL, or HWB |
| |
| // legacy compatibility -- remove when we can |
| static Interpolation FromFlags(uint32_t flags) { |
| return {flags & 1 ? InPremul::kYes : InPremul::kNo, |
| ColorSpace::kDestination, |
| HueMethod::kShorter}; |
| } |
| }; |
| |
| /** |
| * Specification for the colors in a gradient. |
| * |
| * @param colors The span of colors for the gradient. |
| * @param pos Relative positions of each color across the gradient. If empty, |
| * the the colors are distributed evenly. If this is not null, the values |
| * must lie between 0.0 and 1.0, and be strictly increasing. If the first |
| * value is not 0.0, then an additional color stop is added at position 0.0, |
| * with the same color as colors[0]. If the the last value is less than 1.0, |
| * then an additional color stop is added at position 1.0, with the same color |
| * as colors[count - 1]. |
| * @param mode Tiling mode for the gradient. |
| * @param cs Optional colorspace associated with the span of colors. If this is null, |
| * the colors are treated as sRGB. |
| */ |
| class Colors { |
| public: |
| Colors() {} |
| Colors(SkSpan<const SkColor4f> colors, |
| SkSpan<const float> pos, |
| SkTileMode mode, |
| sk_sp<SkColorSpace> cs = nullptr) |
| : fColors(colors), fPos(pos), fColorSpace(std::move(cs)), fTileMode(mode) { |
| SkASSERT(fPos.size() == 0 || fPos.size() == fColors.size()); |
| |
| // throw away inconsistent inputs |
| if (fPos.size() != fColors.size()) { |
| fPos = {}; |
| } |
| } |
| |
| Colors(SkSpan<const SkColor4f> colors, SkTileMode tm, sk_sp<SkColorSpace> cs = nullptr) |
| : Colors(colors, {}, tm, std::move(cs)) {} |
| |
| SkSpan<const SkColor4f> colors() const { return fColors; } |
| SkSpan<const float> positions() const { return fPos; } |
| const sk_sp<SkColorSpace>& colorSpace() const { return fColorSpace; } |
| SkTileMode tileMode() const { return fTileMode; } |
| |
| private: |
| SkSpan<const SkColor4f> fColors; |
| SkSpan<const float> fPos; |
| sk_sp<SkColorSpace> fColorSpace; |
| SkTileMode fTileMode = SkTileMode::kClamp; |
| }; |
| |
| SkGradient() {} |
| SkGradient(const Colors& colors, const Interpolation& interp) |
| : fColors(colors), fInterpolation(interp) {} |
| |
| const Colors& colors() const { return fColors; } |
| const Interpolation& interpolation() const { return fInterpolation; } |
| |
| private: |
| Colors fColors; |
| Interpolation fInterpolation; |
| }; |
| |
| namespace SkShaders { |
| /** Returns a shader that generates a linear gradient between the two specified points. |
| * If the inputs are invalid, this will return nullptr. |
| * @param points Array of 2 points, the end-points of the line segment |
| * @param grad Description of the colors and interpolation method |
| * @param lm Optional local matrix, may be null |
| */ |
| SK_API sk_sp<SkShader> LinearGradient(const SkPoint pts[2], |
| const SkGradient&, |
| const SkMatrix* lm = nullptr); |
| |
| /** Returns a shader that generates a radial gradient given the center and radius. |
| * @param center The center of the circle for this gradient |
| * @param radius Must be positive. The radius of the circle for this gradient |
| * @param grad Description of the colors and interpolation method |
| * @param lm Optional local matrix, may be null |
| */ |
| SK_API sk_sp<SkShader> RadialGradient(SkPoint center, |
| float radius, |
| const SkGradient& grad, |
| const SkMatrix* lm = nullptr); |
| |
| /** Returns a shader that generates a conical gradient given two circles, or |
| * returns null if the inputs are invalid. The gradient interprets the |
| * two circles according to the following HTML spec. |
| * http://dev.w3.org/html5/2dcontext/#dom-context-2d-createradialgradient |
| * @param start The center of the circle for this gradient |
| * @param startRadius Must be positive. The radius of the circle for this gradient |
| * @param end The center of the circle for this gradient |
| * @param startRadius Must be positive. The radius of the circle for this gradient |
| * @param grad Description of the colors and interpolation method |
| * @param lm Optional local matrix, may be null |
| */ |
| SK_API sk_sp<SkShader> TwoPointConicalGradient(SkPoint start, |
| float startRadius, |
| SkPoint end, |
| float endRadius, |
| const SkGradient& grad, |
| const SkMatrix* lm = nullptr); |
| |
| /** Returns a shader that generates a sweep gradient given a center. |
| * The shader accepts negative angles and angles larger than 360, draws |
| * between 0 and 360 degrees, similar to the CSS conic-gradient |
| * semantics. 0 degrees means horizontal positive x axis. The start angle |
| * must be less than the end angle, otherwise a null pointer is |
| * returned. If color stops do not contain 0 and 1 but are within this |
| * range, the respective outer color stop is repeated for 0 and 1. Color |
| * stops less than 0 are clamped to 0, and greater than 1 are clamped to 1. |
| * @param center The center of the sweep |
| * @param startAngle Start of the angular range, corresponding to pos == 0. |
| * @param endAngle End of the angular range, corresponding to pos == 1. |
| * @param grad Description of the colors and interpolation method |
| * @param lm Optional local matrix, may be null |
| */ |
| SK_API sk_sp<SkShader> SweepGradient(SkPoint center, |
| float startAngle, |
| float endAngle, |
| const SkGradient&, |
| const SkMatrix* lm = nullptr); |
| static inline sk_sp<SkShader> SweepGradient(SkPoint center, |
| const SkGradient& grad, |
| const SkMatrix* lm = nullptr) { |
| return SweepGradient(center, 0, 360, grad, lm); |
| } |
| |
| } // namespace SkShaders |
| |
| #endif |
