AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Better encapsulate Blend, Color and Empty shaders

Browse Source 
Bug: skia:13438
Change-Id: Id1b7e6759144820f200040616deb3a120d809765
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/554405
Commit-Queue: Robert Phillips <robertphillips@google.com>
Reviewed-by: Michael Ludwig <michaelludwig@google.com>
This commit is contained in:
Robert Phillips 2022-07-11 11:47:57 -04:00 committed by SkCQ
parent a43654ec7e
commit fc49c18ca2
20 changed files with 215 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
experimental/sktext/samples/Text.cpp
View File

@ -13,7 +13,6 @@
#include "include/core/SkTime.h"
#include "samplecode/Sample.h"
#include "src/core/SkOSFile.h"
#include "src/shaders/SkColorShader.h"
#include "src/utils/SkOSPath.h"
#include "src/utils/SkUTF.h"
#include "tools/Resources.h"

4
gn/core.gni
View File

@ -469,10 +469,8 @@ skia_core_sources = [
"$_src/shaders/SkColorFilterShader.cpp",
"$_src/shaders/SkColorFilterShader.h",
"$_src/shaders/SkColorShader.cpp",
"$_src/shaders/SkColorShader.h",
"$_src/shaders/SkComposeShader.cpp",
"$_src/shaders/SkComposeShader.h",
"$_src/shaders/SkEmptyShader.h",
"$_src/shaders/SkEmptyShader.cpp",
"$_src/shaders/SkImageShader.cpp",
"$_src/shaders/SkImageShader.h",
"$_src/shaders/SkLocalMatrixShader.cpp",

1
modules/skparagraph/samples/SampleParagraph.cpp
View File

@ -21,7 +21,6 @@
#include "modules/skparagraph/utils/TestFontCollection.h"
#include "samplecode/Sample.h"
#include "src/core/SkOSFile.h"
#include "src/shaders/SkColorShader.h"
#include "src/utils/SkOSPath.h"
#include "src/utils/SkUTF.h"
#include "tools/Resources.h"

4
public.bzl
View File

@ -1410,10 +1410,8 @@ BASE_SRCS_ALL = [
"src/shaders/SkColorFilterShader.cpp",
"src/shaders/SkColorFilterShader.h",
"src/shaders/SkColorShader.cpp",
"src/shaders/SkColorShader.h",
"src/shaders/SkComposeShader.cpp",
"src/shaders/SkComposeShader.h",
"src/shaders/SkEmptyShader.h",
"src/shaders/SkEmptyShader.cpp",
"src/shaders/SkImageShader.cpp",
"src/shaders/SkImageShader.h",
"src/shaders/SkLocalMatrixShader.cpp",

1
samplecode/SampleTextBox.cpp
View File

@ -21,7 +21,6 @@
#include "include/utils/SkRandom.h"
#include "modules/skshaper/include/SkShaper.h"
#include "src/core/SkOSFile.h"
#include "src/shaders/SkColorShader.h"
#include "src/utils/SkUTF.h"
typedef std::unique_ptr<SkShaper> (*ShaperFactory)();

2
src/core/SkDraw_atlas.cpp
View File

@ -183,7 +183,7 @@ void SkDraw::drawAtlas(const SkRSXform xform[],
};
if (gUseSkVMBlitter || !rpblit()) {
auto updateShader = as_SB(atlasShader)->updatableShader(&alloc);
SkUpdatableShader* updateShader = as_SB(atlasShader)->updatableShader(&alloc);
UpdatableColorShader* colorShader = nullptr;
sk_sp<SkShader> shader;
if (colors) {

3
src/core/SkVMBlitter.cpp
View File

@ -21,7 +21,6 @@
#include "src/core/SkVM.h"
#include "src/core/SkVMBlitter.h"
#include "src/shaders/SkColorFilterShader.h"
#include "src/shaders/SkColorShader.h"
#include <cinttypes>
@ -228,7 +227,7 @@ SkVMBlitter::Params SkVMBlitter::EffectiveParams(const SkPixmap& device,
// but if there is a shader, it's modulated by the paint alpha.
sk_sp<SkShader> shader = paint.refShader();
if (!shader) {
shader = sk_make_sp<SkColor4Shader>(paint.getColor4f(), nullptr);
shader = SkShaders::Color(paint.getColor4f(), nullptr);
} else if (paint.getAlphaf() < 1.0f) {
shader = sk_make_sp<SkColorFilterShader>(std::move(shader),
paint.getAlphaf(),

11
src/ports/SkGlobalInitialization_default.cpp
View File

@ -36,9 +36,6 @@
#include "src/effects/SkTrimPE.h"
#include "src/shaders/SkBitmapProcShader.h"
#include "src/shaders/SkColorFilterShader.h"
#include "src/shaders/SkColorShader.h"
#include "src/shaders/SkComposeShader.h"
#include "src/shaders/SkEmptyShader.h"
#include "src/shaders/SkImageShader.h"
#include "src/shaders/SkLocalMatrixShader.h"
#include "src/shaders/SkPictureShader.h"
@ -65,11 +62,11 @@
*/
void SkFlattenable::PrivateInitializer::InitEffects() {
// Shaders.
SK_REGISTER_FLATTENABLE(SkColor4Shader);
SkRegisterColor4ShaderFlattenable();
SK_REGISTER_FLATTENABLE(SkColorFilterShader);
SK_REGISTER_FLATTENABLE(SkColorShader);
SK_REGISTER_FLATTENABLE(SkShader_Blend);
SK_REGISTER_FLATTENABLE(SkEmptyShader);
SkRegisterColorShaderFlattenable();
SkRegisterComposeShaderFlattenable();
SkRegisterEmptyShaderFlattenable();
SK_REGISTER_FLATTENABLE(SkLocalMatrixShader);
SK_REGISTER_FLATTENABLE(SkPictureShader);
SkGradientShader::RegisterFlattenables();

4
src/shaders/BUILD.bazel
View File

@ -10,10 +10,8 @@ SHADER_FILES = [
"SkColorFilterShader.cpp",
"SkColorFilterShader.h",
"SkColorShader.cpp",
"SkColorShader.h",
"SkComposeShader.cpp",
"SkComposeShader.h",
"SkEmptyShader.h",
"SkEmptyShader.cpp",
"SkImageShader.cpp",
"SkImageShader.h",
"SkLocalMatrixShader.cpp",

111
src/shaders/SkColorShader.cpp
View File

@ -5,9 +5,8 @@
* found in the LICENSE file.
*/
#include "src/shaders/SkColorShader.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkFlattenable.h"
#include "src/core/SkArenaAlloc.h"
#include "src/core/SkColorSpacePriv.h"
#include "src/core/SkColorSpaceXformSteps.h"
@ -21,6 +20,89 @@
#include "src/core/SkPaintParamsKey.h"
#endif
#include "src/shaders/SkShaderBase.h"
class SkShaderCodeDictionary;
/** \class SkColorShader
A Shader that represents a single color. In general, this effect can be
accomplished by just using the color field on the paint, but if an
actual shader object is needed, this provides that feature.
*/
class SkColorShader : public SkShaderBase {
public:
/** Create a ColorShader that ignores the color in the paint, and uses the
specified color. Note: like all shaders, at draw time the paint's alpha
will be respected, and is applied to the specified color.
*/
explicit SkColorShader(SkColor c);
bool isOpaque() const override;
bool isConstant() const override { return true; }
GradientType asAGradient(GradientInfo* info) const override;
#if SK_SUPPORT_GPU
std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const GrFPArgs&) const override;
#endif
#ifdef SK_ENABLE_SKSL
void addToKey(const SkKeyContext&,
SkPaintParamsKeyBuilder*,
SkPipelineDataGatherer*) const override;
#endif
private:
friend void ::SkRegisterColorShaderFlattenable();
SK_FLATTENABLE_HOOKS(SkColorShader)
void flatten(SkWriteBuffer&) const override;
bool onAsLuminanceColor(SkColor* lum) const override {
*lum = fColor;
return true;
}
bool onAppendStages(const SkStageRec&) const override;
skvm::Color onProgram(skvm::Builder*, skvm::Coord device, skvm::Coord local, skvm::Color paint,
const SkMatrixProvider&, const SkMatrix* localM, const SkColorInfo& dst,
skvm::Uniforms* uniforms, SkArenaAlloc*) const override;
SkColor fColor;
};
class SkColor4Shader : public SkShaderBase {
public:
SkColor4Shader(const SkColor4f&, sk_sp<SkColorSpace>);
bool isOpaque() const override { return fColor.isOpaque(); }
bool isConstant() const override { return true; }
#if SK_SUPPORT_GPU
std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const GrFPArgs&) const override;
#endif
#ifdef SK_ENABLE_SKSL
void addToKey(const SkKeyContext&,
SkPaintParamsKeyBuilder*,
SkPipelineDataGatherer*) const override;
#endif
private:
friend void ::SkRegisterColor4ShaderFlattenable();
SK_FLATTENABLE_HOOKS(SkColor4Shader)
void flatten(SkWriteBuffer&) const override;
bool onAppendStages(const SkStageRec&) const override;
skvm::Color onProgram(skvm::Builder*, skvm::Coord device, skvm::Coord local, skvm::Color paint,
const SkMatrixProvider&, const SkMatrix* localM, const SkColorInfo& dst,
skvm::Uniforms* uniforms, SkArenaAlloc*) const override;
sk_sp<SkColorSpace> fColorSpace;
const SkColor4f fColor;
};
SkColorShader::SkColorShader(SkColor c) : fColor(c) {}
bool SkColorShader::isOpaque() const {
@ -73,14 +155,6 @@ void SkColor4Shader::flatten(SkWriteBuffer& buffer) const {
}
}
sk_sp<SkShader> SkShaders::Color(const SkColor4f& color, sk_sp<SkColorSpace> space) {
if (!SkScalarsAreFinite(color.vec(), 4)) {
return nullptr;
}
return sk_make_sp<SkColor4Shader>(color, std::move(space));
}
bool SkColorShader::onAppendStages(const SkStageRec& rec) const {
SkColor4f color = SkColor4f::FromColor(fColor);
SkColorSpaceXformSteps(sk_srgb_singleton(), kUnpremul_SkAlphaType,
@ -157,3 +231,20 @@ void SkColor4Shader::addToKey(const SkKeyContext& keyContext,
builder->endBlock();
}
#endif
sk_sp<SkShader> SkShaders::Color(SkColor color) { return sk_make_sp<SkColorShader>(color); }
sk_sp<SkShader> SkShaders::Color(const SkColor4f& color, sk_sp<SkColorSpace> space) {
if (!SkScalarsAreFinite(color.vec(), 4)) {
return nullptr;
}
return sk_make_sp<SkColor4Shader>(color, std::move(space));
}
void SkRegisterColor4ShaderFlattenable() {
SK_REGISTER_FLATTENABLE(SkColor4Shader);
}
void SkRegisterColorShaderFlattenable() {
SK_REGISTER_FLATTENABLE(SkColorShader);
}

92
src/shaders/SkColorShader.h
View File

@ -1,92 +0,0 @@
/*
* Copyright 2007 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkColorShader_DEFINED
#define SkColorShader_DEFINED
#include "src/shaders/SkShaderBase.h"
class SkShaderCodeDictionary;
/** \class SkColorShader
A Shader that represents a single color. In general, this effect can be
accomplished by just using the color field on the paint, but if an
actual shader object is needed, this provides that feature.
*/
class SkColorShader : public SkShaderBase {
public:
/** Create a ColorShader that ignores the color in the paint, and uses the
specified color. Note: like all shaders, at draw time the paint's alpha
will be respected, and is applied to the specified color.
*/
explicit SkColorShader(SkColor c);
bool isOpaque() const override;
bool isConstant() const override { return true; }
GradientType asAGradient(GradientInfo* info) const override;
#if SK_SUPPORT_GPU
std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const GrFPArgs&) const override;
#endif
#ifdef SK_ENABLE_SKSL
void addToKey(const SkKeyContext&,
SkPaintParamsKeyBuilder*,
SkPipelineDataGatherer*) const override;
#endif
private:
SK_FLATTENABLE_HOOKS(SkColorShader)
void flatten(SkWriteBuffer&) const override;
bool onAsLuminanceColor(SkColor* lum) const override {
*lum = fColor;
return true;
}
bool onAppendStages(const SkStageRec&) const override;
skvm::Color onProgram(skvm::Builder*, skvm::Coord device, skvm::Coord local, skvm::Color paint,
const SkMatrixProvider&, const SkMatrix* localM, const SkColorInfo& dst,
skvm::Uniforms* uniforms, SkArenaAlloc*) const override;
SkColor fColor;
};
class SkColor4Shader : public SkShaderBase {
public:
SkColor4Shader(const SkColor4f&, sk_sp<SkColorSpace>);
bool isOpaque() const override { return fColor.isOpaque(); }
bool isConstant() const override { return true; }
#if SK_SUPPORT_GPU
std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const GrFPArgs&) const override;
#endif
#ifdef SK_ENABLE_SKSL
void addToKey(const SkKeyContext&,
SkPaintParamsKeyBuilder*,
SkPipelineDataGatherer*) const override;
#endif
private:
SK_FLATTENABLE_HOOKS(SkColor4Shader)
void flatten(SkWriteBuffer&) const override;
bool onAppendStages(const SkStageRec&) const override;
skvm::Color onProgram(skvm::Builder*, skvm::Coord device, skvm::Coord local, skvm::Color paint,
const SkMatrixProvider&, const SkMatrix* localM, const SkColorInfo& dst,
skvm::Uniforms* uniforms, SkArenaAlloc*) const override;
sk_sp<SkColorSpace> fColorSpace;
const SkColor4f fColor;
};
#endif

96
src/shaders/SkComposeShader.cpp
View File

@ -6,6 +6,7 @@
*/
#include "include/core/SkColorFilter.h"
#include "include/core/SkFlattenable.h"
#include "include/core/SkString.h"
#include "include/private/SkColorData.h"
#include "src/core/SkArenaAlloc.h"
@ -16,8 +17,6 @@
#include "src/core/SkRuntimeEffectPriv.h"
#include "src/core/SkVM.h"
#include "src/core/SkWriteBuffer.h"
#include "src/shaders/SkColorShader.h"
#include "src/shaders/SkComposeShader.h"
#ifdef SK_ENABLE_SKSL
#include "src/core/SkKeyHelpers.h"
@ -47,31 +46,49 @@ private:
} // namespace
sk_sp<SkShader> SkShaders::Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src) {
if (!src || !dst) {
return nullptr;
}
switch (mode) {
case SkBlendMode::kClear: return Color(0);
case SkBlendMode::kDst: return dst;
case SkBlendMode::kSrc: return src;
default: break;
}
return sk_sp<SkShader>(new SkShader_Blend(mode, std::move(dst), std::move(src)));
}
sk_sp<SkShader> SkShaders::Blend(sk_sp<SkBlender> blender, sk_sp<SkShader> dst, sk_sp<SkShader> src) {
if (!src || !dst) {
return nullptr;
}
if (!blender) {
return SkShaders::Blend(SkBlendMode::kSrcOver, std::move(dst), std::move(src));
}
return sk_sp<SkShader>(new SkShader_Blend(std::move(blender), std::move(dst), std::move(src)));
}
///////////////////////////////////////////////////////////////////////////////
class SkShader_Blend final : public SkShaderBase {
public:
SkShader_Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src)
: fDst(std::move(dst))
, fSrc(std::move(src))
, fBlender(nullptr)
, fMode(mode)
{}
SkShader_Blend(sk_sp<SkBlender> blender, sk_sp<SkShader> dst, sk_sp<SkShader> src);
#if SK_SUPPORT_GPU
std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const GrFPArgs&) const override;
#endif
#ifdef SK_ENABLE_SKSL
void addToKey(const SkKeyContext&,
SkPaintParamsKeyBuilder*,
SkPipelineDataGatherer*) const override;
#endif
protected:
SkShader_Blend(SkReadBuffer&);
void flatten(SkWriteBuffer&) const override;
bool onAppendStages(const SkStageRec&) const override;
skvm::Color onProgram(skvm::Builder*, skvm::Coord device, skvm::Coord local, skvm::Color paint,
const SkMatrixProvider&, const SkMatrix* localM, const SkColorInfo& dst,
skvm::Uniforms*, SkArenaAlloc*) const override;
private:
friend void ::SkRegisterComposeShaderFlattenable();
SK_FLATTENABLE_HOOKS(SkShader_Blend)
sk_sp<SkShader> fDst;
sk_sp<SkShader> fSrc;
sk_sp<SkBlender> fBlender; // if null, use fMode
SkBlendMode fMode; // only use if fBlender is null
using INHERITED = SkShaderBase;
};
SkShader_Blend::SkShader_Blend(sk_sp<SkBlender> blender, sk_sp<SkShader> dst, sk_sp<SkShader> src)
: fDst(std::move(dst))
, fSrc(std::move(src))
@ -209,3 +226,32 @@ void SkShader_Blend::addToKey(const SkKeyContext& keyContext,
builder->endBlock();
}
#endif
sk_sp<SkShader> SkShaders::Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src) {
if (!src || !dst) {
return nullptr;
}
switch (mode) {
case SkBlendMode::kClear: return Color(0);
case SkBlendMode::kDst: return dst;
case SkBlendMode::kSrc: return src;
default: break;
}
return sk_sp<SkShader>(new SkShader_Blend(mode, std::move(dst), std::move(src)));
}
sk_sp<SkShader> SkShaders::Blend(sk_sp<SkBlender> blender,
sk_sp<SkShader> dst,
sk_sp<SkShader> src) {
if (!src || !dst) {
return nullptr;
}
if (!blender) {
return SkShaders::Blend(SkBlendMode::kSrcOver, std::move(dst), std::move(src));
}
return sk_sp<SkShader>(new SkShader_Blend(std::move(blender), std::move(dst), std::move(src)));
}
void SkRegisterComposeShaderFlattenable() {
SK_REGISTER_FLATTENABLE(SkShader_Blend);
}

58
src/shaders/SkComposeShader.h
View File

@ -1,58 +0,0 @@
/*
* Copyright 2006 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkComposeShader_DEFINED
#define SkComposeShader_DEFINED
#include "include/core/SkBlendMode.h"
#include "src/core/SkBlendModePriv.h"
#include "src/core/SkBlenderBase.h"
#include "src/shaders/SkShaderBase.h"
class SkShaderCodeDictionary;
class SkShader_Blend final : public SkShaderBase {
public:
SkShader_Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src)
: fDst(std::move(dst))
, fSrc(std::move(src))
, fBlender(nullptr)
, fMode(mode)
{}
SkShader_Blend(sk_sp<SkBlender> blender, sk_sp<SkShader> dst, sk_sp<SkShader> src);
#if SK_SUPPORT_GPU
std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const GrFPArgs&) const override;
#endif
#ifdef SK_ENABLE_SKSL
void addToKey(const SkKeyContext&,
SkPaintParamsKeyBuilder*,
SkPipelineDataGatherer*) const override;
#endif
protected:
SkShader_Blend(SkReadBuffer&);
void flatten(SkWriteBuffer&) const override;
bool onAppendStages(const SkStageRec&) const override;
skvm::Color onProgram(skvm::Builder*, skvm::Coord device, skvm::Coord local, skvm::Color paint,
const SkMatrixProvider&, const SkMatrix* localM, const SkColorInfo& dst,
skvm::Uniforms*, SkArenaAlloc*) const override;
private:
SK_FLATTENABLE_HOOKS(SkShader_Blend)
sk_sp<SkShader> fDst;
sk_sp<SkShader> fSrc;
sk_sp<SkBlender> fBlender; // if null, use fMode
SkBlendMode fMode; // only use if fBlender is null
using INHERITED = SkShaderBase;
};
#endif

25
src/shaders/SkEmptyShader.h → src/shaders/SkEmptyShader.cpp
View File

@ -1,16 +1,14 @@
/*
* Copyright 2011 Google Inc.
* Copyright 2022 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkEmptyShader_DEFINED
#define SkEmptyShader_DEFINED
#include "src/shaders/SkShaderBase.h"
// TODO: move this to private, as there is a public factory on SkShader
#include "include/core/SkFlattenable.h"
#include "src/core/SkVM.h"
/**
* \class SkEmptyShader
@ -42,9 +40,24 @@ protected:
skvm::Uniforms*, SkArenaAlloc*) const override;
private:
friend void ::SkRegisterEmptyShaderFlattenable();
SK_FLATTENABLE_HOOKS(SkEmptyShader)
using INHERITED = SkShaderBase;
};
#endif
skvm::Color SkEmptyShader::onProgram(skvm::Builder*, skvm::Coord, skvm::Coord, skvm::Color,
const SkMatrixProvider&, const SkMatrix*, const SkColorInfo&,
skvm::Uniforms*, SkArenaAlloc*) const {
return {}; // signal failure
}
sk_sp<SkFlattenable> SkEmptyShader::CreateProc(SkReadBuffer&) {
return SkShaders::Empty();
}
sk_sp<SkShader> SkShaders::Empty() { return sk_make_sp<SkEmptyShader>(); }
void SkRegisterEmptyShaderFlattenable() {
SK_REGISTER_FLATTENABLE(SkEmptyShader);
}

5
src/shaders/SkImageShader.cpp
View File

@ -21,7 +21,6 @@
#include "src/core/SkWriteBuffer.h"
#include "src/image/SkImage_Base.h"
#include "src/shaders/SkBitmapProcShader.h"
#include "src/shaders/SkEmptyShader.h"
#include "src/shaders/SkTransformShader.h"
#ifdef SK_ENABLE_SKSL
@ -301,7 +300,7 @@ sk_sp<SkShader> SkImageShader::MakeRaw(sk_sp<SkImage> image,
return nullptr;
}
if (!image) {
return sk_make_sp<SkEmptyShader>();
return SkShaders::Empty();
}
return sk_sp<SkShader>{new SkImageShader(
image, SkRect::Make(image->dimensions()), tmx, tmy, options, localMatrix,
@ -323,7 +322,7 @@ sk_sp<SkShader> SkImageShader::MakeSubset(sk_sp<SkImage> image,
}
}
if (!image || subset.isEmpty()) {
return sk_make_sp<SkEmptyShader>();
return SkShaders::Empty();
}
// Validate subset and check if we can drop it

20
src/shaders/SkShader.cpp
View File

@ -7,7 +7,6 @@
#include "include/core/SkMallocPixelRef.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPicture.h"
#include "include/core/SkScalar.h"
#include "src/core/SkArenaAlloc.h"
#include "src/core/SkColorSpacePriv.h"
@ -16,13 +15,9 @@
#include "src/core/SkRasterPipeline.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkTLazy.h"
#include "src/core/SkVM.h"
#include "src/core/SkWriteBuffer.h"
#include "src/shaders/SkBitmapProcShader.h"
#include "src/shaders/SkColorShader.h"
#include "src/shaders/SkEmptyShader.h"
#include "src/shaders/SkImageShader.h"
#include "src/shaders/SkPictureShader.h"
#include "src/shaders/SkShaderBase.h"
#include "src/shaders/SkTransformShader.h"
@ -163,9 +158,6 @@ void SkShaderBase::addToKey(const SkKeyContext& keyContext,
}
#endif
sk_sp<SkShader> SkShaders::Empty() { return sk_make_sp<SkEmptyShader>(); }
sk_sp<SkShader> SkShaders::Color(SkColor color) { return sk_make_sp<SkColorShader>(color); }
sk_sp<SkShader> SkBitmap::makeShader(SkTileMode tmx, SkTileMode tmy,
const SkSamplingOptions& sampling,
const SkMatrix* lm) const {
@ -289,15 +281,3 @@ skvm::Coord SkShaderBase::ApplyMatrix(skvm::Builder* p, const SkMatrix& m,
}
return {x,y};
}
///////////////////////////////////////////////////////////////////////////////////////////////////
skvm::Color SkEmptyShader::onProgram(skvm::Builder*, skvm::Coord, skvm::Coord, skvm::Color,
const SkMatrixProvider&, const SkMatrix*, const SkColorInfo&,
skvm::Uniforms*, SkArenaAlloc*) const {
return {}; // signal failure
}
sk_sp<SkFlattenable> SkEmptyShader::CreateProc(SkReadBuffer&) {
return SkShaders::Empty();
}

5
src/shaders/SkShaderBase.h
View File

@ -304,4 +304,9 @@ inline const SkShaderBase* as_SB(const sk_sp<SkShader>& shader) {
return static_cast<SkShaderBase*>(shader.get());
}
void SkRegisterColor4ShaderFlattenable();
void SkRegisterColorShaderFlattenable();
void SkRegisterComposeShaderFlattenable();
void SkRegisterEmptyShaderFlattenable();
#endif // SkShaderBase_DEFINED

3
tests/GradientTest.cpp
View File

@ -16,7 +16,6 @@
#include "src/core/SkMatrixProvider.h"
#include "src/core/SkTLazy.h"
#include "src/gpu/ganesh/GrColorInfo.h"
#include "src/shaders/SkColorShader.h"
#include "tests/Test.h"
// https://code.google.com/p/chromium/issues/detail?id=448299
@ -77,7 +76,7 @@ static void none_gradproc(skiatest::Reporter* reporter, const GradRec&, const Gr
}
static void color_gradproc(skiatest::Reporter* reporter, const GradRec& rec, const GradRec&) {
sk_sp<SkShader> s(new SkColorShader(rec.fColors[0]));
sk_sp<SkShader> s(SkShaders::Color(rec.fColors[0]));
REPORTER_ASSERT(reporter, SkShader::kColor_GradientType == s->asAGradient(nullptr));
SkShader::GradientInfo info;

13
tests/ShaderOpacityTest.cpp
View File

@ -10,7 +10,6 @@
#include "include/core/SkShader.h"
#include "include/core/SkSurface.h"
#include "include/effects/SkGradientShader.h"
#include "src/shaders/SkColorShader.h"
#include "tests/Test.h"
#include "tools/ToolUtils.h"
@ -85,12 +84,12 @@ static void test_gradient(skiatest::Reporter* reporter) {
}
static void test_color(skiatest::Reporter* reporter) {
SkColorShader colorShader1(SkColorSetARGB(0,0,0,0));
REPORTER_ASSERT(reporter, !colorShader1.isOpaque());
SkColorShader colorShader2(SkColorSetARGB(0xFF,0,0,0));
REPORTER_ASSERT(reporter, colorShader2.isOpaque());
SkColorShader colorShader3(SkColorSetARGB(0x7F,0,0,0));
REPORTER_ASSERT(reporter, !colorShader3.isOpaque());
sk_sp<SkShader> colorShader1 = SkShaders::Color(SkColorSetARGB(0,0,0,0));
REPORTER_ASSERT(reporter, !colorShader1->isOpaque());
sk_sp<SkShader> colorShader2 = SkShaders::Color(SkColorSetARGB(0xFF,0,0,0));
REPORTER_ASSERT(reporter, colorShader2->isOpaque());
sk_sp<SkShader> colorShader3 = SkShaders::Color(SkColorSetARGB(0x7F,0,0,0));
REPORTER_ASSERT(reporter, !colorShader3->isOpaque());
}
DEF_TEST(ShaderOpacity, reporter) {