1 /*
2 * Copyright 2012 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
8 #include "SkColorSpaceXformer.h"
9 #include "SkRadialGradient.h"
10 #include "SkRasterPipeline.h"
11 #include "SkReadBuffer.h"
12 #include "SkWriteBuffer.h"
13
14 namespace {
15
rad_to_unit_matrix(const SkPoint & center,SkScalar radius)16 SkMatrix rad_to_unit_matrix(const SkPoint& center, SkScalar radius) {
17 SkScalar inv = SkScalarInvert(radius);
18
19 SkMatrix matrix;
20 matrix.setTranslate(-center.fX, -center.fY);
21 matrix.postScale(inv, inv);
22 return matrix;
23 }
24
25 } // namespace
26
27 /////////////////////////////////////////////////////////////////////
28
SkRadialGradient(const SkPoint & center,SkScalar radius,const Descriptor & desc)29 SkRadialGradient::SkRadialGradient(const SkPoint& center, SkScalar radius, const Descriptor& desc)
30 : SkGradientShaderBase(desc, rad_to_unit_matrix(center, radius))
31 , fCenter(center)
32 , fRadius(radius) {
33 }
34
asAGradient(GradientInfo * info) const35 SkShader::GradientType SkRadialGradient::asAGradient(GradientInfo* info) const {
36 if (info) {
37 commonAsAGradient(info);
38 info->fPoint[0] = fCenter;
39 info->fRadius[0] = fRadius;
40 }
41 return kRadial_GradientType;
42 }
43
CreateProc(SkReadBuffer & buffer)44 sk_sp<SkFlattenable> SkRadialGradient::CreateProc(SkReadBuffer& buffer) {
45 DescriptorScope desc;
46 if (!desc.unflatten(buffer)) {
47 return nullptr;
48 }
49 const SkPoint center = buffer.readPoint();
50 const SkScalar radius = buffer.readScalar();
51 return SkGradientShader::MakeRadial(center, radius, desc.fColors, std::move(desc.fColorSpace),
52 desc.fPos, desc.fCount, desc.fTileMode, desc.fGradFlags,
53 desc.fLocalMatrix);
54 }
55
flatten(SkWriteBuffer & buffer) const56 void SkRadialGradient::flatten(SkWriteBuffer& buffer) const {
57 this->INHERITED::flatten(buffer);
58 buffer.writePoint(fCenter);
59 buffer.writeScalar(fRadius);
60 }
61
62 /////////////////////////////////////////////////////////////////////
63
64 #if SK_SUPPORT_GPU
65
66 #include "SkGr.h"
67 #include "GrShaderCaps.h"
68 #include "glsl/GrGLSLFragmentShaderBuilder.h"
69
70 class GrRadialGradient : public GrGradientEffect {
71 public:
72 class GLSLRadialProcessor;
73
Make(const CreateArgs & args)74 static std::unique_ptr<GrFragmentProcessor> Make(const CreateArgs& args) {
75 return GrGradientEffect::AdjustFP(std::unique_ptr<GrRadialGradient>(
76 new GrRadialGradient(args)),
77 args);
78 }
79
name() const80 const char* name() const override { return "Radial Gradient"; }
81
clone() const82 std::unique_ptr<GrFragmentProcessor> clone() const override {
83 return std::unique_ptr<GrFragmentProcessor>(new GrRadialGradient(*this));
84 }
85
86 private:
GrRadialGradient(const CreateArgs & args)87 explicit GrRadialGradient(const CreateArgs& args)
88 : INHERITED(kGrRadialGradient_ClassID, args, args.fShader->colorsAreOpaque()) {}
89
GrRadialGradient(const GrRadialGradient & that)90 explicit GrRadialGradient(const GrRadialGradient& that) : INHERITED(that) {}
91
92 GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
93
94 GR_DECLARE_FRAGMENT_PROCESSOR_TEST
95
96 typedef GrGradientEffect INHERITED;
97 };
98
99 /////////////////////////////////////////////////////////////////////
100
101 class GrRadialGradient::GLSLRadialProcessor : public GrGradientEffect::GLSLProcessor {
102 public:
GLSLRadialProcessor(const GrProcessor &)103 GLSLRadialProcessor(const GrProcessor&) {}
104
105 virtual void emitCode(EmitArgs&) override;
106
107 private:
108 typedef GrGradientEffect::GLSLProcessor INHERITED;
109
110 };
111
112 /////////////////////////////////////////////////////////////////////
113
onCreateGLSLInstance() const114 GrGLSLFragmentProcessor* GrRadialGradient::onCreateGLSLInstance() const {
115 return new GrRadialGradient::GLSLRadialProcessor(*this);
116 }
117
118 /////////////////////////////////////////////////////////////////////
119
120 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrRadialGradient);
121
122 #if GR_TEST_UTILS
TestCreate(GrProcessorTestData * d)123 std::unique_ptr<GrFragmentProcessor> GrRadialGradient::TestCreate(GrProcessorTestData* d) {
124 sk_sp<SkShader> shader;
125 do {
126 RandomGradientParams params(d->fRandom);
127 SkPoint center = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
128 SkScalar radius = d->fRandom->nextUScalar1();
129 shader = params.fUseColors4f
130 ? SkGradientShader::MakeRadial(center, radius, params.fColors4f,
131 params.fColorSpace, params.fStops,
132 params.fColorCount, params.fTileMode)
133 : SkGradientShader::MakeRadial(center, radius, params.fColors,
134 params.fStops, params.fColorCount,
135 params.fTileMode);
136 } while (!shader);
137 GrTest::TestAsFPArgs asFPArgs(d);
138 std::unique_ptr<GrFragmentProcessor> fp = as_SB(shader)->asFragmentProcessor(asFPArgs.args());
139 GrAlwaysAssert(fp);
140 return fp;
141 }
142 #endif
143
144 /////////////////////////////////////////////////////////////////////
145
emitCode(EmitArgs & args)146 void GrRadialGradient::GLSLRadialProcessor::emitCode(EmitArgs& args) {
147 const GrRadialGradient& ge = args.fFp.cast<GrRadialGradient>();
148 this->emitUniforms(args.fUniformHandler, ge);
149 SkString t("length(");
150 t.append(args.fFragBuilder->ensureCoords2D(args.fTransformedCoords[0]));
151 t.append(")");
152 this->emitColor(args.fFragBuilder,
153 args.fUniformHandler,
154 args.fShaderCaps,
155 ge, t.c_str(),
156 args.fOutputColor,
157 args.fInputColor,
158 args.fTexSamplers);
159 }
160
161 /////////////////////////////////////////////////////////////////////
162
asFragmentProcessor(const GrFPArgs & args) const163 std::unique_ptr<GrFragmentProcessor> SkRadialGradient::asFragmentProcessor(
164 const GrFPArgs& args) const {
165 SkASSERT(args.fContext);
166
167 SkMatrix matrix;
168 if (!this->getLocalMatrix().invert(&matrix)) {
169 return nullptr;
170 }
171 if (args.fLocalMatrix) {
172 SkMatrix inv;
173 if (!args.fLocalMatrix->invert(&inv)) {
174 return nullptr;
175 }
176 matrix.postConcat(inv);
177 }
178 matrix.postConcat(fPtsToUnit);
179
180 return GrRadialGradient::Make(GrGradientEffect::CreateArgs(
181 args.fContext, this, &matrix, fTileMode, args.fDstColorSpaceInfo->colorSpace()));
182 }
183
184 #endif
185
onMakeColorSpace(SkColorSpaceXformer * xformer) const186 sk_sp<SkShader> SkRadialGradient::onMakeColorSpace(SkColorSpaceXformer* xformer) const {
187 const AutoXformColors xformedColors(*this, xformer);
188 return SkGradientShader::MakeRadial(fCenter, fRadius, xformedColors.fColors.get(), fOrigPos,
189 fColorCount, fTileMode, fGradFlags,
190 &this->getLocalMatrix());
191 }
192
appendGradientStages(SkArenaAlloc *,SkRasterPipeline * p,SkRasterPipeline *) const193 void SkRadialGradient::appendGradientStages(SkArenaAlloc*, SkRasterPipeline* p,
194 SkRasterPipeline*) const {
195 p->append(SkRasterPipeline::xy_to_radius);
196 }
197
198 #ifndef SK_IGNORE_TO_STRING
toString(SkString * str) const199 void SkRadialGradient::toString(SkString* str) const {
200 str->append("SkRadialGradient: (");
201
202 str->append("center: (");
203 str->appendScalar(fCenter.fX);
204 str->append(", ");
205 str->appendScalar(fCenter.fY);
206 str->append(") radius: ");
207 str->appendScalar(fRadius);
208 str->append(" ");
209
210 this->INHERITED::toString(str);
211
212 str->append(")");
213 }
214 #endif
215