blob: b63c519619b11f78ed53b5a35519584ef63f6a29 [file] [log] [blame]
* Copyright 2012 Google Inc.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
#include "src/shaders/gradients/SkLinearGradient.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/effects/SkGradientShader.h"
#include "include/private/base/SkTArray.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkWriteBuffer.h"
#include "src/shaders/SkLocalMatrixShader.h"
#include "src/shaders/SkShaderBase.h"
#include <cstdint>
#include <utility>
class SkArenaAlloc;
class SkRasterPipeline;
enum class SkTileMode;
static SkMatrix pts_to_unit_matrix(const SkPoint pts[2]) {
SkVector vec = pts[1] - pts[0];
SkScalar mag = vec.length();
SkScalar inv = mag ? SkScalarInvert(mag) : 0;
SkMatrix matrix;
matrix.setSinCos(-vec.fY, vec.fX, pts[0].fX, pts[0].fY);
matrix.postTranslate(-pts[0].fX, -pts[0].fY);
matrix.postScale(inv, inv);
return matrix;
SkLinearGradient::SkLinearGradient(const SkPoint pts[2], const Descriptor& desc)
: SkGradientBaseShader(desc, pts_to_unit_matrix(pts)), fStart(pts[0]), fEnd(pts[1]) {}
sk_sp<SkFlattenable> SkLinearGradient::CreateProc(SkReadBuffer& buffer) {
DescriptorScope desc;
SkMatrix legacyLocalMatrix;
if (!desc.unflatten(buffer, &legacyLocalMatrix)) {
return nullptr;
SkPoint pts[2];
pts[0] = buffer.readPoint();
pts[1] = buffer.readPoint();
return SkGradientShader::MakeLinear(pts,
void SkLinearGradient::flatten(SkWriteBuffer& buffer) const {
void SkLinearGradient::appendGradientStages(SkArenaAlloc*, SkRasterPipeline*,
SkRasterPipeline*) const {
// No extra stage needed for linear gradients.
SkShaderBase::GradientType SkLinearGradient::asGradient(GradientInfo* info,
SkMatrix* localMatrix) const {
if (info) {
info->fPoint[0] = fStart;
info->fPoint[1] = fEnd;
if (localMatrix) {
*localMatrix = SkMatrix::I();
return GradientType::kLinear;
sk_sp<SkShader> SkGradientShader::MakeLinear(const SkPoint pts[2],
const SkColor4f colors[],
sk_sp<SkColorSpace> colorSpace,
const SkScalar pos[],
int colorCount,
SkTileMode mode,
const Interpolation& interpolation,
const SkMatrix* localMatrix) {
if (!pts || !SkScalarIsFinite((pts[1] - pts[0]).length())) {
return nullptr;
if (!SkGradientBaseShader::ValidGradient(colors, colorCount, mode, interpolation)) {
return nullptr;
if (1 == colorCount) {
return SkShaders::Color(colors[0], std::move(colorSpace));
if (localMatrix && !localMatrix->invert(nullptr)) {
return nullptr;
if (SkScalarNearlyZero((pts[1] - pts[0]).length(),
SkGradientBaseShader::kDegenerateThreshold)) {
// Degenerate gradient, the only tricky complication is when in clamp mode, the limit of
// the gradient approaches two half planes of solid color (first and last). However, they
// are divided by the line perpendicular to the start and end point, which becomes undefined
// once start and end are exactly the same, so just use the end color for a stable solution.
return SkGradientBaseShader::MakeDegenerateGradient(
colors, pos, colorCount, std::move(colorSpace), mode);
SkGradientBaseShader::Descriptor desc(
colors, std::move(colorSpace), pos, colorCount, mode, interpolation);
return SkLocalMatrixShader::MakeWrapped<SkLinearGradient>(localMatrix, pts, desc);
sk_sp<SkShader> SkGradientShader::MakeLinear(const SkPoint pts[2],
const SkColor colors[],
const SkScalar pos[],
int colorCount,
SkTileMode mode,
uint32_t flags,
const SkMatrix* localMatrix) {
SkColorConverter converter(colors, colorCount);
return MakeLinear(pts, converter.fColors4f.begin(), nullptr, pos, colorCount, mode, flags,
void SkRegisterLinearGradientShaderFlattenable() {