Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(78)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp

Issue 238443006: Add gpu fast path for two point conical gradients (Closed) Base URL: https://skia.googlesource.com/skia.git@ConicalFlip
Patch Set: Created 6 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« gm/gradients_2pt_conical.cpp ('K') | « gyp/gmslides.gypi ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1
1 /* 2 /*
2 * Copyright 2014 Google Inc. 3 * Copyright 2014 Google Inc.
3 * 4 *
4 * Use of this source code is governed by a BSD-style license that can be 5 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file. 6 * found in the LICENSE file.
6 */ 7 */
7 8
8 #include "SkTwoPointConicalGradient_gpu.h" 9 #include "SkTwoPointConicalGradient_gpu.h"
9 10
10 #include "SkTwoPointConicalGradient.h" 11 #include "SkTwoPointConicalGradient.h"
11 12
12 #if SK_SUPPORT_GPU 13 #if SK_SUPPORT_GPU
13 #include "GrTBackendEffectFactory.h" 14 #include "GrTBackendEffectFactory.h"
14 // For brevity 15 // For brevity
15 typedef GrGLUniformManager::UniformHandle UniformHandle; 16 typedef GrGLUniformManager::UniformHandle UniformHandle;
16 17
18 static const SkScalar kErrorTol = 0.00001;
19
20 enum ConicalType {
bsalomon 2014/04/21 18:54:58 comment here... what are inside, outside, and edge
21 kInside_ConicalType,
22 kOutside_ConicalType,
23 kEdge_ConicalType,
24 };
25
17 ////////////////////////////////////////////////////////////////////////////// 26 //////////////////////////////////////////////////////////////////////////////
18 27
19 static void set_matrix_default_conical(const SkTwoPointConicalGradient& shader, 28 static void set_matrix_edge_conical(const SkTwoPointConicalGradient& shader,
20 SkMatrix* invLMatrix) { 29 SkMatrix* invLMatrix) {
21 // Inverse of the current local matrix is passed in then, 30 // Inverse of the current local matrix is passed in then,
22 // translate to center1, rotate so center2 is on x axis. 31 // translate to center1, rotate so center2 is on x axis.
23 const SkPoint& center1 = shader.getStartCenter(); 32 const SkPoint& center1 = shader.getStartCenter();
24 const SkPoint& center2 = shader.getEndCenter(); 33 const SkPoint& center2 = shader.getEndCenter();
25 34
26 invLMatrix->postTranslate(-center1.fX, -center1.fY); 35 invLMatrix->postTranslate(-center1.fX, -center1.fY);
27 36
28 SkPoint diff = center2 - center1; 37 SkPoint diff = center2 - center1;
29 SkScalar diffLen = diff.length(); 38 SkScalar diffLen = diff.length();
30 if (0 != diffLen) { 39 if (0 != diffLen) {
31 SkScalar invDiffLen = SkScalarInvert(diffLen); 40 SkScalar invDiffLen = SkScalarInvert(diffLen);
32 SkMatrix rot; 41 SkMatrix rot;
33 rot.setSinCos(-SkScalarMul(invDiffLen, diff.fY), 42 rot.setSinCos(-SkScalarMul(invDiffLen, diff.fY),
34 SkScalarMul(invDiffLen, diff.fX)); 43 SkScalarMul(invDiffLen, diff.fX));
35 invLMatrix->postConcat(rot); 44 invLMatrix->postConcat(rot);
36 } 45 }
37 } 46 }
38 47
39 class GLDefault2PtConicalEffect; 48 class GLEdge2PtConicalEffect;
40 49
41 class Default2PtConicalEffect : public GrGradientEffect { 50 class Edge2PtConicalEffect : public GrGradientEffect {
42 public: 51 public:
43 52
44 static GrEffectRef* Create(GrContext* ctx, 53 static GrEffectRef* Create(GrContext* ctx,
45 const SkTwoPointConicalGradient& shader, 54 const SkTwoPointConicalGradient& shader,
46 const SkMatrix& matrix, 55 const SkMatrix& matrix,
47 SkShader::TileMode tm) { 56 SkShader::TileMode tm) {
48 AutoEffectUnref effect(SkNEW_ARGS(Default2PtConicalEffect, (ctx, shader, matrix, tm))); 57 AutoEffectUnref effect(SkNEW_ARGS(Edge2PtConicalEffect, (ctx, shader, ma trix, tm)));
49 return CreateEffectRef(effect); 58 return CreateEffectRef(effect);
50 } 59 }
51 60
52 virtual ~Default2PtConicalEffect() { } 61 virtual ~Edge2PtConicalEffect() {}
53 62
54 static const char* Name() { return "Two-Point Conical Gradient"; } 63 static const char* Name() { return "Two-Point Conical Gradient Edge Touching "; }
55 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; 64 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
56 65
57 // The radial gradient parameters can collapse to a linear (instead of quadr atic) equation. 66 // The radial gradient parameters can collapse to a linear (instead of quadr atic) equation.
58 bool isDegenerate() const { return SkScalarAbs(fDiffRadius) == SkScalarAbs(f CenterX1); }
59 bool isFlipped() const { return fIsFlipped; }
60 SkScalar center() const { return fCenterX1; } 67 SkScalar center() const { return fCenterX1; }
61 SkScalar diffRadius() const { return fDiffRadius; } 68 SkScalar diffRadius() const { return fDiffRadius; }
62 SkScalar radius() const { return fRadius0; } 69 SkScalar radius() const { return fRadius0; }
63 70
64 typedef GLDefault2PtConicalEffect GLEffect; 71 typedef GLEdge2PtConicalEffect GLEffect;
65 72
66 private: 73 private:
67 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { 74 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
68 const Default2PtConicalEffect& s = CastEffect<Default2PtConicalEffect>(s Base); 75 const Edge2PtConicalEffect& s = CastEffect<Edge2PtConicalEffect>(sBase);
69 return (INHERITED::onIsEqual(sBase) && 76 return (INHERITED::onIsEqual(sBase) &&
70 this->fCenterX1 == s.fCenterX1 && 77 this->fCenterX1 == s.fCenterX1 &&
71 this->fRadius0 == s.fRadius0 && 78 this->fRadius0 == s.fRadius0 &&
72 this->fDiffRadius == s.fDiffRadius && 79 this->fDiffRadius == s.fDiffRadius);
73 this->fIsFlipped == s.fIsFlipped);
74 } 80 }
75 81
76 Default2PtConicalEffect(GrContext* ctx, 82 Edge2PtConicalEffect(GrContext* ctx,
77 const SkTwoPointConicalGradient& shader, 83 const SkTwoPointConicalGradient& shader,
78 const SkMatrix& matrix, 84 const SkMatrix& matrix,
79 SkShader::TileMode tm) 85 SkShader::TileMode tm)
80 : INHERITED(ctx, shader, matrix, tm), 86 : INHERITED(ctx, shader, matrix, tm),
81 fCenterX1(shader.getCenterX1()), 87 fCenterX1(shader.getCenterX1()),
82 fRadius0(shader.getStartRadius()), 88 fRadius0(shader.getStartRadius()),
83 fDiffRadius(shader.getDiffRadius()), 89 fDiffRadius(shader.getDiffRadius()){
84 fIsFlipped(shader.isFlippedGrad()) { 90 // We should only be calling this shader if we are degenerate case with touching circles
91 SkASSERT(SkScalarAbs(fDiffRadius) - SkScalarAbs(fCenterX1) < kErrorTol) ;
92
85 // We pass the linear part of the quadratic as a varying. 93 // We pass the linear part of the quadratic as a varying.
86 // float b = -2.0 * (fCenterX1 * x + fRadius0 * fDiffRadius * z) 94 // float b = -2.0 * (fCenterX1 * x + fRadius0 * fDiffRadius * z)
87 fBTransform = this->getCoordTransform(); 95 fBTransform = this->getCoordTransform();
88 SkMatrix& bMatrix = *fBTransform.accessMatrix(); 96 SkMatrix& bMatrix = *fBTransform.accessMatrix();
89 SkScalar r0dr = SkScalarMul(fRadius0, fDiffRadius); 97 SkScalar r0dr = SkScalarMul(fRadius0, fDiffRadius);
90 bMatrix[SkMatrix::kMScaleX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMat rix::kMScaleX]) + 98 bMatrix[SkMatrix::kMScaleX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMat rix::kMScaleX]) +
91 SkScalarMul(r0dr, bMatrix[SkMatrix:: kMPersp0])); 99 SkScalarMul(r0dr, bMatrix[SkMatrix:: kMPersp0]));
92 bMatrix[SkMatrix::kMSkewX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatr ix::kMSkewX]) + 100 bMatrix[SkMatrix::kMSkewX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatr ix::kMSkewX]) +
93 SkScalarMul(r0dr, bMatrix[SkMatrix::k MPersp1])); 101 SkScalarMul(r0dr, bMatrix[SkMatrix::k MPersp1]));
94 bMatrix[SkMatrix::kMTransX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMat rix::kMTransX]) + 102 bMatrix[SkMatrix::kMTransX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMat rix::kMTransX]) +
95 SkScalarMul(r0dr, bMatrix[SkMatrix:: kMPersp2])); 103 SkScalarMul(r0dr, bMatrix[SkMatrix:: kMPersp2]));
96 this->addCoordTransform(&fBTransform); 104 this->addCoordTransform(&fBTransform);
97 } 105 }
98 106
99 GR_DECLARE_EFFECT_TEST; 107 GR_DECLARE_EFFECT_TEST;
100 108
101 // @{ 109 // @{
102 // Cache of values - these can change arbitrarily, EXCEPT 110 // Cache of values - these can change arbitrarily, EXCEPT
103 // we shouldn't change between degenerate and non-degenerate?! 111 // we shouldn't change between degenerate and non-degenerate?!
104 112
105 GrCoordTransform fBTransform; 113 GrCoordTransform fBTransform;
106 SkScalar fCenterX1; 114 SkScalar fCenterX1;
107 SkScalar fRadius0; 115 SkScalar fRadius0;
108 SkScalar fDiffRadius; 116 SkScalar fDiffRadius;
109 bool fIsFlipped;
110 117
111 // @} 118 // @}
112 119
113 typedef GrGradientEffect INHERITED; 120 typedef GrGradientEffect INHERITED;
114 }; 121 };
115 122
116 class GLDefault2PtConicalEffect : public GrGLGradientEffect { 123 class GLEdge2PtConicalEffect : public GrGLGradientEffect {
117 public: 124 public:
118 GLDefault2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDra wEffect&); 125 GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEf fect&);
119 virtual ~GLDefault2PtConicalEffect() { } 126 virtual ~GLEdge2PtConicalEffect() { }
120 127
121 virtual void emitCode(GrGLShaderBuilder*, 128 virtual void emitCode(GrGLShaderBuilder*,
122 const GrDrawEffect&, 129 const GrDrawEffect&,
123 EffectKey, 130 EffectKey,
124 const char* outputColor, 131 const char* outputColor,
125 const char* inputColor, 132 const char* inputColor,
126 const TransformedCoordsArray&, 133 const TransformedCoordsArray&,
127 const TextureSamplerArray&) SK_OVERRIDE; 134 const TextureSamplerArray&) SK_OVERRIDE;
128 virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVER RIDE; 135 virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVER RIDE;
129 136
130 static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps); 137 static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
131 138
132 protected: 139 protected:
133 UniformHandle fParamUni; 140 UniformHandle fParamUni;
134 141
135 const char* fVSVaryingName; 142 const char* fVSVaryingName;
136 const char* fFSVaryingName; 143 const char* fFSVaryingName;
137 144
138 bool fIsDegenerate;
139 bool fIsFlipped;
140
141 // @{ 145 // @{
142 /// Values last uploaded as uniforms 146 /// Values last uploaded as uniforms
143 147
144 SkScalar fCachedCenter;
145 SkScalar fCachedRadius; 148 SkScalar fCachedRadius;
146 SkScalar fCachedDiffRadius; 149 SkScalar fCachedDiffRadius;
147 150
148 // @} 151 // @}
149 152
150 private: 153 private:
151 typedef GrGLGradientEffect INHERITED; 154 typedef GrGLGradientEffect INHERITED;
152 155
153 }; 156 };
154 157
155 const GrBackendEffectFactory& Default2PtConicalEffect::getFactory() const { 158 const GrBackendEffectFactory& Edge2PtConicalEffect::getFactory() const {
156 return GrTBackendEffectFactory<Default2PtConicalEffect>::getInstance(); 159 return GrTBackendEffectFactory<Edge2PtConicalEffect>::getInstance();
157 } 160 }
158 161
159 GR_DEFINE_EFFECT_TEST(Default2PtConicalEffect); 162 GR_DEFINE_EFFECT_TEST(Edge2PtConicalEffect);
160 163
161 GrEffectRef* Default2PtConicalEffect::TestCreate(SkRandom* random, 164 GrEffectRef* Edge2PtConicalEffect::TestCreate(SkRandom* random,
162 GrContext* context, 165 GrContext* context,
163 const GrDrawTargetCaps&, 166 const GrDrawTargetCaps&,
164 GrTexture**) { 167 GrTexture**) {
165 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; 168 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
166 SkScalar radius1 = random->nextUScalar1(); 169 SkScalar radius1 = random->nextUScalar1();
167 SkPoint center2; 170 SkPoint center2;
168 SkScalar radius2; 171 SkScalar radius2;
169 do { 172 do {
170 center2.set(random->nextUScalar1(), random->nextUScalar1()); 173 center2.set(random->nextUScalar1(), random->nextUScalar1());
171 radius2 = random->nextUScalar1 (); 174 // Below makes sure that circle one is contained within circle two
175 // and both circles are touching on an edge
176 SkPoint diff = center2 - center1;
177 SkScalar diffLen = diff.length();
178 radius2 = radius1 + diffLen;
172 // If the circles are identical the factory will give us an empty shader . 179 // If the circles are identical the factory will give us an empty shader .
bsalomon 2014/04/21 18:54:58 maybe take this comment out since it isn't the pri
173 } while (radius1 == radius2 && center1 == center2); 180 } while (radius1 == radius2 && center1 == center2);
174 181
175 SkColor colors[kMaxRandomGradientColors]; 182 SkColor colors[kMaxRandomGradientColors];
176 SkScalar stopsArray[kMaxRandomGradientColors]; 183 SkScalar stopsArray[kMaxRandomGradientColors];
177 SkScalar* stops = stopsArray; 184 SkScalar* stops = stopsArray;
178 SkShader::TileMode tm; 185 SkShader::TileMode tm;
179 int colorCount = RandomGradientParams(random, colors, &stops, &tm); 186 int colorCount = RandomGradientParams(random, colors, &stops, &tm);
180 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center 1, radius1, 187 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center 1, radius1,
181 center 2, radius2, 188 center 2, radius2,
182 colors , stops, colorCount, 189 colors , stops, colorCount,
183 tm)); 190 tm));
184 SkPaint paint; 191 SkPaint paint;
185 return shader->asNewEffect(context, paint); 192 return shader->asNewEffect(context, paint);
186 } 193 }
187 194
188 195 GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendEffectFactory& fac tory,
189 ///////////////////////////////////////////////////////////////////// 196 const GrDrawEffect& drawEffect)
190
191 GLDefault2PtConicalEffect::GLDefault2PtConicalEffect(const GrBackendEffectFactor y& factory,
192 const GrDrawEffect& drawEffect)
193 : INHERITED(factory) 197 : INHERITED(factory)
194 , fVSVaryingName(NULL) 198 , fVSVaryingName(NULL)
195 , fFSVaryingName(NULL) 199 , fFSVaryingName(NULL)
196 , fCachedCenter(SK_ScalarMax)
197 , fCachedRadius(-SK_ScalarMax) 200 , fCachedRadius(-SK_ScalarMax)
198 , fCachedDiffRadius(-SK_ScalarMax) { 201 , fCachedDiffRadius(-SK_ScalarMax) {}
199 202
200 const Default2PtConicalEffect& data = drawEffect.castEffect<Default2PtConica lEffect>(); 203 void GLEdge2PtConicalEffect::emitCode(GrGLShaderBuilder* builder,
201 fIsDegenerate = data.isDegenerate(); 204 const GrDrawEffect&,
202 fIsFlipped = data.isFlipped(); 205 EffectKey key,
203 } 206 const char* outputColor,
204 207 const char* inputColor,
205 void GLDefault2PtConicalEffect::emitCode(GrGLShaderBuilder* builder, 208 const TransformedCoordsArray& coords,
206 const GrDrawEffect&, 209 const TextureSamplerArray& samplers) {
207 EffectKey key,
208 const char* outputColor,
209 const char* inputColor,
210 const TransformedCoordsArray& coords,
211 const TextureSamplerArray& samplers) {
212 this->emitUniforms(builder, key); 210 this->emitUniforms(builder, key);
213 fParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_Visibility , 211 fParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_Visibility ,
214 kFloat_GrSLType, "Conical2FSParams", 6) ; 212 kFloat_GrSLType, "Conical2FSParams", 3) ;
215 213
216 SkString cName("c"); 214 SkString cName("c");
217 SkString ac4Name("ac4");
218 SkString dName("d");
219 SkString qName("q");
220 SkString r0Name("r0");
221 SkString r1Name("r1");
222 SkString tName("t"); 215 SkString tName("t");
223 SkString p0; // 4a 216 SkString p0; // start radius
224 SkString p1; // 1/a 217 SkString p1; // start radius squared
225 SkString p2; // distance between centers 218 SkString p2; // difference in radii (r1 - r0)
226 SkString p3; // start radius
227 SkString p4; // start radius squared
228 SkString p5; // difference in radii (r1 - r0)
229 219
230 builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0); 220 builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0);
231 builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1); 221 builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
232 builder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2); 222 builder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2);
233 builder->getUniformVariable(fParamUni).appendArrayAccess(3, &p3);
234 builder->getUniformVariable(fParamUni).appendArrayAccess(4, &p4);
235 builder->getUniformVariable(fParamUni).appendArrayAccess(5, &p5);
236 223
237 // We interpolate the linear component in coords[1]. 224 // We interpolate the linear component in coords[1].
238 SkASSERT(coords[0].type() == coords[1].type()); 225 SkASSERT(coords[0].type() == coords[1].type());
239 const char* coords2D; 226 const char* coords2D;
240 SkString bVar; 227 SkString bVar;
241 if (kVec3f_GrSLType == coords[0].type()) { 228 if (kVec3f_GrSLType == coords[0].type()) {
bsalomon 2014/04/21 18:54:58 There's a helper on GrGLShaderBuilder called ensur
242 builder->fsCodeAppendf("\tvec3 interpolants = vec3(%s.xy, %s.x) / %s.z;\ n", 229 builder->fsCodeAppendf("\tvec3 interpolants = vec3(%s.xy / %s.z, %s.x / %s.z);\n",
243 coords[0].c_str(), coords[1].c_str(), coords[0].c _str()); 230 coords[0].c_str(), coords[0].c_str(), coords[1].c _str(), coords[1].c_str());
244 coords2D = "interpolants.xy"; 231 coords2D = "interpolants.xy";
245 bVar = "interpolants.z"; 232 bVar = "interpolants.z";
246 } else { 233 } else {
247 coords2D = coords[0].c_str(); 234 coords2D = coords[0].c_str();
248 bVar.printf("%s.x", coords[1].c_str()); 235 bVar.printf("%s.x", coords[1].c_str());
249 } 236 }
250 237
251 // output will default to transparent black (we simply won't write anything 238 // output will default to transparent black (we simply won't write anything
252 // else to it if invalid, instead of discarding or returning prematurely) 239 // else to it if invalid, instead of discarding or returning prematurely)
253 builder->fsCodeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor); 240 builder->fsCodeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
254 241
255 // c = (x^2)+(y^2) - params[4] 242 // c = (x^2)+(y^2) - params[1]
256 builder->fsCodeAppendf("\tfloat %s = dot(%s, %s) - %s;\n", 243 builder->fsCodeAppendf("\tfloat %s = dot(%s, %s) - %s;\n",
257 cName.c_str(), coords2D, coords2D, p4.c_str()); 244 cName.c_str(), coords2D, coords2D, p1.c_str());
258 245
259 // Non-degenerate case (quadratic) 246 // linear case: t = -c/b
260 if (!fIsDegenerate) { 247 builder->fsCodeAppendf("\tfloat %s = -(%s / %s);\n", tName.c_str(),
261 248 cName.c_str(), bVar.c_str());
262 // ac4 = params[0] * c 249
263 builder->fsCodeAppendf("\tfloat %s = %s * %s;\n", ac4Name.c_str(), p0.c_ str(), 250 // if r(t) > 0, then t will be the x coordinate
264 cName.c_str()); 251 builder->fsCodeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
265 252 p2.c_str(), p0.c_str());
266 // d = b^2 - ac4 253 builder->fsCodeAppend("\t");
267 builder->fsCodeAppendf("\tfloat %s = %s * %s - %s;\n", dName.c_str(), 254 this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, sample rs);
268 bVar.c_str(), bVar.c_str(), ac4Name.c_str()); 255 builder->fsCodeAppend("\t}\n");
269 256 }
270 // only proceed if discriminant is >= 0 257
271 builder->fsCodeAppendf("\tif (%s >= 0.0) {\n", dName.c_str()); 258 void GLEdge2PtConicalEffect::setData(const GrGLUniformManager& uman,
272 259 const GrDrawEffect& drawEffect) {
273 // intermediate value we'll use to compute the roots
274 // q = -0.5 * (b +/- sqrt(d))
275 builder->fsCodeAppendf("\t\tfloat %s = -0.5 * (%s + (%s < 0.0 ? -1.0 : 1 .0)"
276 " * sqrt(%s));\n", qName.c_str(), bVar.c_str(),
277 bVar.c_str(), dName.c_str());
278
279 // compute both roots
280 // r0 = q * params[1]
281 builder->fsCodeAppendf("\t\tfloat %s = %s * %s;\n", r0Name.c_str(),
282 qName.c_str(), p1.c_str());
283 // r1 = c / q
284 builder->fsCodeAppendf("\t\tfloat %s = %s / %s;\n", r1Name.c_str(),
285 cName.c_str(), qName.c_str());
286
287 // Note: If there are two roots that both generate radius(t) > 0, the
288 // Canvas spec says to choose the larger t.
289
290 // so we'll look at the larger one first (or smaller if flipped):
291 if (!fIsFlipped) {
292 builder->fsCodeAppendf("\t\tfloat %s = max(%s, %s);\n", tName.c_str( ),
293 r0Name.c_str(), r1Name.c_str());
294 } else {
295 builder->fsCodeAppendf("\t\tfloat %s = min(%s, %s);\n", tName.c_str( ),
296 r0Name.c_str(), r1Name.c_str());
297 }
298
299 // if r(t) > 0, then we're done; t will be our x coordinate
300 builder->fsCodeAppendf("\t\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
301 p5.c_str(), p3.c_str());
302
303 builder->fsCodeAppend("\t\t");
304 this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, sa mplers);
305
306 // otherwise, if r(t) for the larger root was <= 0, try the other root
307 builder->fsCodeAppend("\t\t} else {\n");
308 if (!fIsFlipped) {
309 builder->fsCodeAppendf("\t\t\t%s = min(%s, %s);\n", tName.c_str(),
310 r0Name.c_str(), r1Name.c_str());
311 } else {
312 builder->fsCodeAppendf("\t\t\t%s = max(%s, %s);\n", tName.c_str(),
313 r0Name.c_str(), r1Name.c_str());
314 }
315
316 // if r(t) > 0 for the smaller root, then t will be our x coordinate
317 builder->fsCodeAppendf("\t\t\tif (%s * %s + %s > 0.0) {\n",
318 tName.c_str(), p5.c_str(), p3.c_str());
319
320 builder->fsCodeAppend("\t\t\t");
321 this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, sa mplers);
322
323 // end if (r(t) > 0) for smaller root
324 builder->fsCodeAppend("\t\t\t}\n");
325 // end if (r(t) > 0), else, for larger root
326 builder->fsCodeAppend("\t\t}\n");
327 // end if (discriminant >= 0)
328 builder->fsCodeAppend("\t}\n");
329 } else {
330
331 // linear case: t = -c/b
332 builder->fsCodeAppendf("\tfloat %s = -(%s / %s);\n", tName.c_str(),
333 cName.c_str(), bVar.c_str());
334
335 // if r(t) > 0, then t will be the x coordinate
336 builder->fsCodeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
337 p5.c_str(), p3.c_str());
338 builder->fsCodeAppend("\t");
339 this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, sa mplers);
340 builder->fsCodeAppend("\t}\n");
341 }
342 }
343
344 void GLDefault2PtConicalEffect::setData(const GrGLUniformManager& uman,
345 const GrDrawEffect& drawEffect) {
346 INHERITED::setData(uman, drawEffect); 260 INHERITED::setData(uman, drawEffect);
347 const Default2PtConicalEffect& data = drawEffect.castEffect<Default2PtConica lEffect>(); 261 const Edge2PtConicalEffect& data = drawEffect.castEffect<Edge2PtConicalEffec t>();
348 SkASSERT(data.isDegenerate() == fIsDegenerate);
349 SkASSERT(data.isFlipped() == fIsFlipped);
350 SkScalar centerX1 = data.center();
351 SkScalar radius0 = data.radius(); 262 SkScalar radius0 = data.radius();
352 SkScalar diffRadius = data.diffRadius(); 263 SkScalar diffRadius = data.diffRadius();
353 264
354 if (fCachedCenter != centerX1 || 265 if (fCachedRadius != radius0 ||
355 fCachedRadius != radius0 ||
356 fCachedDiffRadius != diffRadius) { 266 fCachedDiffRadius != diffRadius) {
357 267
358 SkScalar a = SkScalarMul(centerX1, centerX1) - diffRadius * diffRadius; 268 float values[3] = {
359
360 // When we're in the degenerate (linear) case, the second
361 // value will be INF but the program doesn't read it. (We
362 // use the same 6 uniforms even though we don't need them
363 // all in the linear case just to keep the code complexity
364 // down).
365 float values[6] = {
366 SkScalarToFloat(a * 4),
367 1.f / (SkScalarToFloat(a)),
368 SkScalarToFloat(centerX1),
369 SkScalarToFloat(radius0), 269 SkScalarToFloat(radius0),
370 SkScalarToFloat(SkScalarMul(radius0, radius0)), 270 SkScalarToFloat(SkScalarMul(radius0, radius0)),
371 SkScalarToFloat(diffRadius) 271 SkScalarToFloat(diffRadius)
372 }; 272 };
373 273
374 uman.set1fv(fParamUni, 6, values); 274 uman.set1fv(fParamUni, 3, values);
375 fCachedCenter = centerX1;
376 fCachedRadius = radius0; 275 fCachedRadius = radius0;
377 fCachedDiffRadius = diffRadius; 276 fCachedDiffRadius = diffRadius;
378 } 277 }
379 } 278 }
380 279
381 GrGLEffect::EffectKey GLDefault2PtConicalEffect::GenKey(const GrDrawEffect& draw Effect, 280 GrGLEffect::EffectKey GLEdge2PtConicalEffect::GenKey(const GrDrawEffect& drawEff ect,
382 const GrGLCaps&) { 281 const GrGLCaps&) {
282 return GenBaseGradientKey(drawEffect);
283 }
284
285 //////////////////////////////////////////////////////////////////////////////
286 // Focal Conical Gradients
287 //////////////////////////////////////////////////////////////////////////////
288
289 static ConicalType set_matrix_focal_conical(const SkTwoPointConicalGradient& sha der,
290 SkMatrix* invLMatrix, SkScalar* foca lX) {
291 // Inverse of the current local matrix is passed in then,
292 // translate, scale, and rotate such that endCircle is unit circle on x-axis ,
293 // and focal point is at the origin.
294 ConicalType conicalType;
295 const SkPoint& focal = shader.getStartCenter();
296 const SkPoint& centerEnd = shader.getEndCenter();
297 SkScalar radius = shader.getEndRadius();
298 SkScalar invRadius = 1.0 / radius;
299
300 SkMatrix matrix;
301
302 matrix.setTranslate(-centerEnd.fX, -centerEnd.fY);
303 matrix.postScale(invRadius, invRadius);
304
305 SkPoint focalTrans;
306 matrix.mapPoints(&focalTrans, &focal, 1);
307 *focalX = focalTrans.length();
308
309 if (0.0 != *focalX) {
310 SkScalar invFocalX = SkScalarInvert(*focalX);
311 SkMatrix rot;
312 rot.setSinCos(-SkScalarMul(invFocalX, focalTrans.fY),
313 SkScalarMul(invFocalX, focalTrans.fX));
314 matrix.postConcat(rot);
315 }
316
317 matrix.postTranslate(-(*focalX), 0.0);
318
319 // If the focal point is touch the edge of the circle it will
bsalomon 2014/04/21 18:54:58 touch->touching
320 // cause a degenerate case that must be handled separately
321 if (SkScalarAbs(1.0 - (*focalX)) < kErrorTol) {
322 return kEdge_ConicalType;
323 }
324
325 // Scale factor 1 / (1 - focalX * focalX)
326 SkScalar oneMinusF2 = 1.0 - SkScalarMul(*focalX, *focalX);
327 SkScalar s = SkScalarDiv(1.0, oneMinusF2);
328
329
330 if (s >= 0.0) {
331 conicalType = kInside_ConicalType;
332 matrix.postScale(s, s * SkScalarSqrt(oneMinusF2));
333 } else {
334 conicalType = kOutside_ConicalType;
335 matrix.postScale(s, s);
336 }
337
338 invLMatrix->postConcat(matrix);
339
340 return conicalType;
341 }
342
343 //////////////////////////////////////////////////////////////////////////////
344
345 class GLFocalOutside2PtConicalEffect;
346
347 class FocalOutside2PtConicalEffect : public GrGradientEffect {
348 public:
349
350 static GrEffectRef* Create(GrContext* ctx,
351 const SkTwoPointConicalGradient& shader,
352 const SkMatrix& matrix,
353 SkShader::TileMode tm,
354 SkScalar focalX) {
355 AutoEffectUnref effect(SkNEW_ARGS(FocalOutside2PtConicalEffect, (ctx, sh ader, matrix, tm, focalX)));
356 return CreateEffectRef(effect);
357 }
358
359 virtual ~FocalOutside2PtConicalEffect() { }
360
361 static const char* Name() { return "Two-Point Conical Gradient Focal Outside "; }
362 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
363
364 bool isFlipped() const { return fIsFlipped; }
365 SkScalar focal() const { return fFocalX; }
366
367 typedef GLFocalOutside2PtConicalEffect GLEffect;
368
369 private:
370 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
371 const FocalOutside2PtConicalEffect& s = CastEffect<FocalOutside2PtConica lEffect>(sBase);
372 return (INHERITED::onIsEqual(sBase) &&
373 this->fFocalX == s.fFocalX &&
374 this->fIsFlipped == s.fIsFlipped);
375 }
376
377 FocalOutside2PtConicalEffect(GrContext* ctx,
378 const SkTwoPointConicalGradient& shader,
379 const SkMatrix& matrix,
380 SkShader::TileMode tm,
381 SkScalar focalX)
382 : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isF lippedGrad()) {}
383
384 GR_DECLARE_EFFECT_TEST;
385
386 SkScalar fFocalX;
387 bool fIsFlipped;
388
389 typedef GrGradientEffect INHERITED;
390 };
391
392 class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect {
393 public:
394 GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
395 virtual ~GLFocalOutside2PtConicalEffect() { }
396
397 virtual void emitCode(GrGLShaderBuilder*,
398 const GrDrawEffect&,
399 EffectKey,
400 const char* outputColor,
401 const char* inputColor,
402 const TransformedCoordsArray&,
403 const TextureSamplerArray&) SK_OVERRIDE;
404 virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVER RIDE;
405
406 static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
407
408 protected:
409 UniformHandle fParamUni;
410
411 const char* fVSVaryingName;
412 const char* fFSVaryingName;
413
414 bool fIsFlipped;
415
416 // @{
417 /// Values last uploaded as uniforms
418
419 SkScalar fCachedFocal;
420
421 // @}
422
423 private:
424 typedef GrGLGradientEffect INHERITED;
425
426 };
427
428 const GrBackendEffectFactory& FocalOutside2PtConicalEffect::getFactory() const {
429 return GrTBackendEffectFactory<FocalOutside2PtConicalEffect>::getInstance();
430 }
431
432 GR_DEFINE_EFFECT_TEST(FocalOutside2PtConicalEffect);
433
434 GrEffectRef* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random,
435 GrContext* context,
436 const GrDrawTargetCaps&,
437 GrTexture**) {
438 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
439 SkScalar radius1 = 0.0;
440 SkPoint center2;
441 SkScalar radius2;
442 do {
443 center2.set(random->nextUScalar1(), random->nextUScalar1());
444 SkPoint diff = center2 - center1;
445 SkScalar diffLen = diff.length();
446 // Below makes sure that the focal point is not contained within circle two
447 radius2 = random->nextRangeF(0.0, diffLen);
448 // If the circles are identical the factory will give us an empty shader .
bsalomon 2014/04/21 18:54:58 same
449 } while (radius1 == radius2 && center1 == center2);
450
451 SkColor colors[kMaxRandomGradientColors];
452 SkScalar stopsArray[kMaxRandomGradientColors];
453 SkScalar* stops = stopsArray;
454 SkShader::TileMode tm;
455 int colorCount = RandomGradientParams(random, colors, &stops, &tm);
456 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center 1, radius1,
457 center 2, radius2,
458 colors , stops, colorCount,
459 tm));
460 SkPaint paint;
461 return shader->asNewEffect(context, paint);
462 }
463
464 GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendEf fectFactory& factory,
465 const GrDrawEffec t& drawEffect)
466 : INHERITED(factory)
467 , fVSVaryingName(NULL)
468 , fFSVaryingName(NULL)
469 , fCachedFocal(SK_ScalarMax) {
470 const FocalOutside2PtConicalEffect& data = drawEffect.castEffect<FocalOutsid e2PtConicalEffect>();
471 fIsFlipped = data.isFlipped();
472 }
473
474 void GLFocalOutside2PtConicalEffect::emitCode(GrGLShaderBuilder* builder,
475 const GrDrawEffect&,
476 EffectKey key,
477 const char* outputColor,
478 const char* inputColor,
479 const TransformedCoordsArray& coor ds,
480 const TextureSamplerArray& sampler s) {
481 this->emitUniforms(builder, key);
482 fParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_Visibility ,
483 kFloat_GrSLType, "Conical2FSParams", 2) ;
484 SkString tName("t");
485 SkString p0; // focalX
486 SkString p1; // 1 - focalX * focalX
487
488 builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0);
489 builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
490
491 // if we have a vec3 from being in perspective, convert it to a vec2 first
492 const char* coords2D;
493 if (kVec3f_GrSLType == coords[0].type()) {
494 builder->fsCodeAppendf("\tvec2 interpolants = vec2(%s.xy) / %s.z;\n",
495 coords[0].c_str(), coords[0].c_str());
496 coords2D = "interpolants";
497 } else {
498 coords2D = coords[0].c_str();
499 }
500
501 // t = p.x * focal.x +/- sqrt(p.x^2 + (1 - focal.x^2) * p.y^2)
502
503 // output will default to transparent black (we simply won't write anything
504 // else to it if invalid, instead of discarding or returning prematurely)
505 builder->fsCodeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
506
507 builder->fsCodeAppendf("\tfloat xs = %s.x * %s.x;\n", coords2D, coords2D);
508 builder->fsCodeAppendf("\tfloat ys = %s.y * %s.y;\n", coords2D, coords2D);
509 builder->fsCodeAppendf("\tfloat d = xs + %s * ys;\n", p1.c_str());
510
511 // Must check to see if we flipped the circle order (to make sure start radi us < end radius)
512 // If so we must also flip sign on sqrt
513 if (!fIsFlipped) {
514 builder->fsCodeAppendf("\tfloat %s = %s.x * %s + sqrt(d);\n", tName.c_s tr(),
515 coords2D, p0.c_str());
516 } else {
517 builder->fsCodeAppendf("\tfloat %s = %s.x * %s - sqrt(d);\n", tName.c_s tr(),
518 coords2D, p0.c_str());
519 }
520 /*
521 builder->fsCodeAppendf("\tfloat temp = -1.0 * min(d, %s);\n", tName.c_str()) ;
522 builder->fsCodeAppend("\ttemp = clamp(temp, 0.0, 1.0);\n");
523 builder->fsCodeAppend("\ttemp = ceil(temp);\n");
524 this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, sample rs);
525 builder->fsCodeAppendf("\t%s = (1.0 - temp) * %s;\n", outputColor, outputCol or);
526 */
527
528 builder->fsCodeAppendf("\tif (%s >= 0.0 && d >= 0.0) {\n", tName.c_str());
529 builder->fsCodeAppend("\t\t");
530 this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, sample rs);
531 builder->fsCodeAppend("\t}\n");
532 }
533
534 void GLFocalOutside2PtConicalEffect::setData(const GrGLUniformManager& uman,
535 const GrDrawEffect& drawEffect) {
536 INHERITED::setData(uman, drawEffect);
537 const FocalOutside2PtConicalEffect& data = drawEffect.castEffect<FocalOutsid e2PtConicalEffect>();
538 SkASSERT(data.isFlipped() == fIsFlipped);
539 SkScalar focal = data.focal();
540
541 if (fCachedFocal != focal) {
542 SkScalar oneMinus2F = 1.0 - SkScalarMul(focal, focal);
543
544 float values[2] = {
545 SkScalarToFloat(focal),
546 SkScalarToFloat(oneMinus2F),
547 };
548
549 uman.set1fv(fParamUni, 2, values);
550 fCachedFocal = focal;
551 }
552 }
553
554 GrGLEffect::EffectKey GLFocalOutside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
555 const GrGLCaps&) {
383 enum { 556 enum {
384 kIsDegenerate = 1 << kBaseKeyBitCnt, 557 kIsFlipped = 1 << kBaseKeyBitCnt,
385 kIsFlipped = 1 << (kBaseKeyBitCnt + 1),
386 }; 558 };
387 559
388 EffectKey key = GenBaseGradientKey(drawEffect); 560 EffectKey key = GenBaseGradientKey(drawEffect);
389 if (drawEffect.castEffect<Default2PtConicalEffect>().isDegenerate()) { 561
390 key |= kIsDegenerate; 562 if (drawEffect.castEffect<FocalOutside2PtConicalEffect>().isFlipped()) {
391 }
392 if (drawEffect.castEffect<Default2PtConicalEffect>().isFlipped()) {
393 key |= kIsFlipped; 563 key |= kIsFlipped;
394 } 564 }
395 return key; 565 return key;
396 } 566 }
397 567
398 ////////////////////////////////////////////////////////////////////////////// 568 //////////////////////////////////////////////////////////////////////////////
399 569
570 class GLFocalInside2PtConicalEffect;
571
572 class FocalInside2PtConicalEffect : public GrGradientEffect {
573 public:
574
575 static GrEffectRef* Create(GrContext* ctx,
576 const SkTwoPointConicalGradient& shader,
577 const SkMatrix& matrix,
578 SkShader::TileMode tm,
579 SkScalar focalX) {
580 AutoEffectUnref effect(SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, sha der, matrix, tm, focalX)));
581 return CreateEffectRef(effect);
582 }
583
584 virtual ~FocalInside2PtConicalEffect() {}
585
586 static const char* Name() { return "Two-Point Conical Gradient Focal Inside" ; }
587 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
588
589 SkScalar focal() const { return fFocalX; }
590
591 typedef GLFocalInside2PtConicalEffect GLEffect;
592
593 private:
594 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
595 const FocalInside2PtConicalEffect& s = CastEffect<FocalInside2PtConicalE ffect>(sBase);
596 return (INHERITED::onIsEqual(sBase) &&
597 this->fFocalX == s.fFocalX);
598 }
599
600 FocalInside2PtConicalEffect(GrContext* ctx,
601 const SkTwoPointConicalGradient& shader,
602 const SkMatrix& matrix,
603 SkShader::TileMode tm,
604 SkScalar focalX)
605 : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {}
606
607 GR_DECLARE_EFFECT_TEST;
608
609 SkScalar fFocalX;
610
611 typedef GrGradientEffect INHERITED;
612 };
613
614 class GLFocalInside2PtConicalEffect : public GrGLGradientEffect {
615 public:
616 GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory, const G rDrawEffect&);
617 virtual ~GLFocalInside2PtConicalEffect() {}
618
619 virtual void emitCode(GrGLShaderBuilder*,
620 const GrDrawEffect&,
621 EffectKey,
622 const char* outputColor,
623 const char* inputColor,
624 const TransformedCoordsArray&,
625 const TextureSamplerArray&) SK_OVERRIDE;
626 virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVER RIDE;
627
628 static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
629
630 protected:
631 UniformHandle fFocalUni;
632
633 const char* fVSVaryingName;
634 const char* fFSVaryingName;
635
636 // @{
637 /// Values last uploaded as uniforms
638
639 SkScalar fCachedFocal;
640
641 // @}
642
643 private:
644 typedef GrGLGradientEffect INHERITED;
645
646 };
647
648 const GrBackendEffectFactory& FocalInside2PtConicalEffect::getFactory() const {
649 return GrTBackendEffectFactory<FocalInside2PtConicalEffect>::getInstance();
650 }
651
652 GR_DEFINE_EFFECT_TEST(FocalInside2PtConicalEffect);
653
654 GrEffectRef* FocalInside2PtConicalEffect::TestCreate(SkRandom* random,
655 GrContext* context,
656 const GrDrawTargetCaps&,
657 GrTexture**) {
658 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
659 SkScalar radius1 = 0.0;
660 SkPoint center2;
661 SkScalar radius2;
662 do {
663 center2.set(random->nextUScalar1(), random->nextUScalar1());
664 // Below makes sure radius2 is larger enouch such that the focal point
665 // is inside the end circle
666 SkScalar increase = random->nextUScalar1();
667 SkPoint diff = center2 - center1;
668 SkScalar diffLen = diff.length();
669 radius2 = diffLen + increase;
670 // If the circles are identical the factory will give us an empty shader .
671 } while (radius1 == radius2 && center1 == center2);
672
673 SkColor colors[kMaxRandomGradientColors];
674 SkScalar stopsArray[kMaxRandomGradientColors];
675 SkScalar* stops = stopsArray;
676 SkShader::TileMode tm;
677 int colorCount = RandomGradientParams(random, colors, &stops, &tm);
678 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center 1, radius1,
679 center 2, radius2,
680 colors , stops, colorCount,
681 tm));
682 SkPaint paint;
683 return shader->asNewEffect(context, paint);
684 }
685
686 GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendEffe ctFactory& factory,
687 const GrDrawEffect& drawEffect)
688 : INHERITED(factory)
689 , fVSVaryingName(NULL)
690 , fFSVaryingName(NULL)
691 , fCachedFocal(SK_ScalarMax) {}
692
693 void GLFocalInside2PtConicalEffect::emitCode(GrGLShaderBuilder* builder,
694 const GrDrawEffect&,
695 EffectKey key,
696 const char* outputColor,
697 const char* inputColor,
698 const TransformedCoordsArray& coord s,
699 const TextureSamplerArray& samplers ) {
700 this->emitUniforms(builder, key);
701 fFocalUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
702 kFloat_GrSLType, "Conical2FSParams");
703 SkString tName("t");
704
705 // this is the distance along x-axis from the end center to focal point in
706 // transformed coordinates
707 GrGLShaderVar focal = builder->getUniformVariable(fFocalUni);
708
709 // if we have a vec3 from being in perspective, convert it to a vec2 first
710 const char* coords2D;
711 if (kVec3f_GrSLType == coords[0].type()) {
712 builder->fsCodeAppendf("\tvec2 interpolants = vec2(%s.xy) / %s.z;\n",
713 coords[0].c_str(), coords[0].c_str());
714 coords2D = "interpolants";
715 } else {
716 coords2D = coords[0].c_str();
717 }
718
719 // output will default to transparent black (we simply won't write anything
720 // else to it if invalid, instead of discarding or returning prematurely)
721 builder->fsCodeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
bsalomon 2014/04/21 18:54:58 I think this initialization only needs to happen i
722
723 // t = p.x * focalX + length(p)
724 builder->fsCodeAppendf("\tfloat %s = %s.x * %s + length(%s);\n", tName.c_st r(),
725 coords2D, focal.c_str(), coords2D);
726
727 this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, sample rs);
728 }
729
730 void GLFocalInside2PtConicalEffect::setData(const GrGLUniformManager& uman,
731 const GrDrawEffect& drawEffect) {
732 INHERITED::setData(uman, drawEffect);
733 const FocalInside2PtConicalEffect& data = drawEffect.castEffect<FocalInside2 PtConicalEffect>();
734 SkScalar focal = data.focal();
735
736 if (fCachedFocal != focal) {
737 uman.set1f(fFocalUni, SkScalarToFloat(focal));
738 fCachedFocal = focal;
739 }
740 }
741
742 GrGLEffect::EffectKey GLFocalInside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
743 const GrGLCaps&) {
744 return GenBaseGradientKey(drawEffect);
745 }
746
747 //////////////////////////////////////////////////////////////////////////////
748 // Circle Conical Gradients
749 //////////////////////////////////////////////////////////////////////////////
750
751 struct CircleConicalInfo {
752 SkPoint fCenterEnd;
753 SkScalar fA;
754 SkScalar fB;
755 SkScalar fC;
756 };
757
758 // Returns focal distance along x-axis in transformed coords
759 static ConicalType set_matrix_circle_conical(const SkTwoPointConicalGradient& sh ader,
760 SkMatrix* invLMatrix, CircleConical Info* info) {
761 // Inverse of the current local matrix is passed in then,
762 // translate and scale such that start circle is on the origin and has radiu s 1
763 const SkPoint& centerStart = shader.getStartCenter();
764 const SkPoint& centerEnd = shader.getEndCenter();
765 SkScalar radiusStart = shader.getStartRadius();
766 SkScalar radiusEnd = shader.getEndRadius();
767
768 SkMatrix matrix;
769
770 matrix.setTranslate(-centerStart.fX, -centerStart.fY);
771
772 SkScalar invStartRad = 1.0 / radiusStart;
773 matrix.postScale(invStartRad, invStartRad);
774
775 radiusEnd /= radiusStart;
776
777 SkPoint centerEndTrans;
778 matrix.mapPoints(&centerEndTrans, &centerEnd, 1);
779
780 SkScalar A = centerEndTrans.fX * centerEndTrans.fX + centerEndTrans.fY * cen terEndTrans.fY
781 - radiusEnd * radiusEnd + 2 * radiusEnd - 1;
782
783 // check to see if start circle is inside end circle with edges touching
784 // if touching we return that it is of kEdge_ConicalType, and leave the matr ix setting
785 // to the edge shader.
786 if (SkScalarAbs(A) < kErrorTol) {
787 return kEdge_ConicalType;
788 }
789
790 SkScalar C = 1.0 / A;
791 SkScalar B = (radiusEnd - 1.0) * C;
792
793 matrix.postScale(C, C);
794
795 invLMatrix->postConcat(matrix);
796
797 info->fCenterEnd = centerEndTrans;
798 info->fA = A;
799 info->fB = B;
800 info->fC = C;
801
802 // if A ends up being negative, the start circle is contained completely ins ide the end cirlce
803 if (A < 0.0) {
804 return kInside_ConicalType;
805 }
806 return kOutside_ConicalType;
807 }
808
809 class GLCircleInside2PtConicalEffect;
810
811 class CircleInside2PtConicalEffect : public GrGradientEffect {
812 public:
813
814 static GrEffectRef* Create(GrContext* ctx,
815 const SkTwoPointConicalGradient& shader,
816 const SkMatrix& matrix,
817 SkShader::TileMode tm,
818 const CircleConicalInfo& info) {
819 AutoEffectUnref effect(SkNEW_ARGS(CircleInside2PtConicalEffect, (ctx, sh ader, matrix, tm, info)));
820 return CreateEffectRef(effect);
821 }
822
823 virtual ~CircleInside2PtConicalEffect() {}
824
825 static const char* Name() { return "Two-Point Conical Gradient Inside"; }
826 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
827
828 SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
829 SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
830 SkScalar A() const { return fInfo.fA; }
831 SkScalar B() const { return fInfo.fB; }
832 SkScalar C() const { return fInfo.fC; }
833
834 typedef GLCircleInside2PtConicalEffect GLEffect;
835
836 private:
837 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
838 const CircleInside2PtConicalEffect& s = CastEffect<CircleInside2PtConica lEffect>(sBase);
839 return (INHERITED::onIsEqual(sBase) &&
840 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
841 this->fInfo.fA == s.fInfo.fA &&
842 this->fInfo.fB == s.fInfo.fB &&
843 this->fInfo.fC == s.fInfo.fC);
844 }
845
846 CircleInside2PtConicalEffect(GrContext* ctx,
847 const SkTwoPointConicalGradient& shader,
848 const SkMatrix& matrix,
849 SkShader::TileMode tm,
850 const CircleConicalInfo& info)
851 : INHERITED(ctx, shader, matrix, tm), fInfo(info) {}
852
853 GR_DECLARE_EFFECT_TEST;
854
855 const CircleConicalInfo fInfo;
856
857 typedef GrGradientEffect INHERITED;
858 };
859
860 class GLCircleInside2PtConicalEffect : public GrGLGradientEffect {
861 public:
862 GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
863 virtual ~GLCircleInside2PtConicalEffect() {}
864
865 virtual void emitCode(GrGLShaderBuilder*,
866 const GrDrawEffect&,
867 EffectKey,
868 const char* outputColor,
869 const char* inputColor,
870 const TransformedCoordsArray&,
871 const TextureSamplerArray&) SK_OVERRIDE;
872 virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVER RIDE;
873
874 static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
875
876 protected:
877 UniformHandle fCenterUni;
878 UniformHandle fParamUni;
879
880 const char* fVSVaryingName;
881 const char* fFSVaryingName;
882
883 // @{
884 /// Values last uploaded as uniforms
885
886 SkScalar fCachedCenterX;
887 SkScalar fCachedCenterY;
888 SkScalar fCachedA;
889 SkScalar fCachedB;
890 SkScalar fCachedC;
891
892 // @}
893
894 private:
895 typedef GrGLGradientEffect INHERITED;
896
897 };
898
899 const GrBackendEffectFactory& CircleInside2PtConicalEffect::getFactory() const {
900 return GrTBackendEffectFactory<CircleInside2PtConicalEffect>::getInstance();
901 }
902
903 GR_DEFINE_EFFECT_TEST(CircleInside2PtConicalEffect);
904
905 GrEffectRef* CircleInside2PtConicalEffect::TestCreate(SkRandom* random,
906 GrContext* context,
907 const GrDrawTargetCaps&,
908 GrTexture**) {
909 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
910 SkScalar radius1 = random->nextUScalar1() + 0.0001; // make sure radius1 != 0
911 SkPoint center2;
912 SkScalar radius2;
913 do {
914 center2.set(random->nextUScalar1(), random->nextUScalar1());
915 // Below makes sure that circle one is contained within circle two
916 SkScalar increase = random->nextUScalar1();
917 SkPoint diff = center2 - center1;
918 SkScalar diffLen = diff.length();
919 radius2 = radius1 + diffLen + increase;
920 // If the circles are identical the factory will give us an empty shader .
921 } while (radius1 == radius2 && center1 == center2);
922
923 SkColor colors[kMaxRandomGradientColors];
924 SkScalar stopsArray[kMaxRandomGradientColors];
925 SkScalar* stops = stopsArray;
926 SkShader::TileMode tm;
927 int colorCount = RandomGradientParams(random, colors, &stops, &tm);
928 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center 1, radius1,
929 center 2, radius2,
930 colors , stops, colorCount,
931 tm));
932 SkPaint paint;
933 return shader->asNewEffect(context, paint);
934 }
935
936 GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendEf fectFactory& factory,
937 const GrDrawEffec t& drawEffect)
938 : INHERITED(factory)
939 , fVSVaryingName(NULL)
940 , fFSVaryingName(NULL)
941 , fCachedCenterX(SK_ScalarMax)
942 , fCachedCenterY(SK_ScalarMax)
943 , fCachedA(SK_ScalarMax)
944 , fCachedB(SK_ScalarMax)
945 , fCachedC(SK_ScalarMax) {}
946
947 void GLCircleInside2PtConicalEffect::emitCode(GrGLShaderBuilder* builder,
948 const GrDrawEffect&,
949 EffectKey key,
950 const char* outputColor,
951 const char* inputColor,
952 const TransformedCoordsArray& coor ds,
953 const TextureSamplerArray& sampler s) {
954 this->emitUniforms(builder, key);
955 fCenterUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
956 kVec2f_GrSLType, "Conical2FSCenter");
957 fParamUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
958 kVec3f_GrSLType, "Conical2FSParams");
959 SkString tName("t");
960
961 GrGLShaderVar center = builder->getUniformVariable(fCenterUni);
962 // params.x = A
963 // params.y = B
964 // params.z = C
965 GrGLShaderVar params = builder->getUniformVariable(fParamUni);
966
967 // if we have a vec3 from being in perspective, convert it to a vec2 first
968 const char* coords2D;
969 if (kVec3f_GrSLType == coords[0].type()) {
970 builder->fsCodeAppendf("\tvec2 interpolants = vec2(%s.xy) / %s.z;\n",
971 coords[0].c_str(), coords[0].c_str());
972 coords2D = "interpolants";
973 } else {
974 coords2D = coords[0].c_str();
975 }
976
977 // output will default to transparent black (we simply won't write anything
978 // else to it if invalid, instead of discarding or returning prematurely)
979 builder->fsCodeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
980
981 // p = coords2D
982 // e = center end
983 // r = radius end
984 // A = dot(e, e) - r^2 + 2 * r - 1
985 // B = (r -1) / A
986 // C = 1 / A
987 // d = dot(e, p) + B
988 // t = d +/- sqrt(d^2 - A * dot(p, p) + C)
989 builder->fsCodeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D );
990 builder->fsCodeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, cente r.c_str(), params.c_str());
991 builder->fsCodeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\ n",
992 tName.c_str(), params.c_str(), params.c_str());
993
994 this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, sample rs);
995 }
996
997 void GLCircleInside2PtConicalEffect::setData(const GrGLUniformManager& uman,
998 const GrDrawEffect& drawEffect) {
999 INHERITED::setData(uman, drawEffect);
1000 const CircleInside2PtConicalEffect& data = drawEffect.castEffect<CircleInsid e2PtConicalEffect>();
1001 SkScalar centerX = data.centerX();
1002 SkScalar centerY = data.centerY();
1003 SkScalar A = data.A();
1004 SkScalar B = data.B();
1005 SkScalar C = data.C();
1006
1007 if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
1008 fCachedA != A || fCachedB != B || fCachedC != C) {
1009
1010 uman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(centerY ));
1011 uman.set3f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarTo Float(C));
1012
1013 fCachedCenterX = centerX;
1014 fCachedCenterY = centerY;
1015 fCachedA = A;
1016 fCachedB = B;
1017 fCachedC = C;
1018 }
1019 }
1020
1021 GrGLEffect::EffectKey GLCircleInside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
1022 const GrGLCaps&) {
1023 EffectKey key = GenBaseGradientKey(drawEffect);
1024 return key;
1025 }
1026
1027 //////////////////////////////////////////////////////////////////////////////
1028
1029 class GLCircleOutside2PtConicalEffect;
1030
1031 class CircleOutside2PtConicalEffect : public GrGradientEffect {
1032 public:
1033
1034 static GrEffectRef* Create(GrContext* ctx,
1035 const SkTwoPointConicalGradient& shader,
1036 const SkMatrix& matrix,
1037 SkShader::TileMode tm,
1038 const CircleConicalInfo& info) {
1039 AutoEffectUnref effect(SkNEW_ARGS(CircleOutside2PtConicalEffect, (ctx, s hader, matrix, tm, info)));
1040 return CreateEffectRef(effect);
1041 }
1042
1043 virtual ~CircleOutside2PtConicalEffect() {}
1044
1045 static const char* Name() { return "Two-Point Conical Gradient Outside"; }
1046 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
1047
1048 SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
1049 SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
1050 SkScalar A() const { return fInfo.fA; }
1051 SkScalar B() const { return fInfo.fB; }
1052 SkScalar C() const { return fInfo.fC; }
1053 SkScalar tLimit() const { return fTLimit; }
1054 bool isFlipped() const { return fIsFlipped; }
1055
1056 typedef GLCircleOutside2PtConicalEffect GLEffect;
1057
1058 private:
1059 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
1060 const CircleOutside2PtConicalEffect& s = CastEffect<CircleOutside2PtConi calEffect>(sBase);
1061 return (INHERITED::onIsEqual(sBase) &&
1062 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
1063 this->fInfo.fA == s.fInfo.fA &&
1064 this->fInfo.fB == s.fInfo.fB &&
1065 this->fInfo.fC == s.fInfo.fC &&
1066 this->fTLimit == s.fTLimit &&
1067 this->fIsFlipped == s.fIsFlipped);
1068 }
1069
1070 CircleOutside2PtConicalEffect(GrContext* ctx,
1071 const SkTwoPointConicalGradient& shader,
1072 const SkMatrix& matrix,
1073 SkShader::TileMode tm,
1074 const CircleConicalInfo& info)
1075 : INHERITED(ctx, shader, matrix, tm), fInfo(info) {
1076 if (shader.getStartRadius() != shader.getEndRadius()) {
1077 fTLimit = SkScalarDiv(shader.getStartRadius(), (shader.getStartRadiu s() - shader.getEndRadius()));
1078 } else {
1079 fTLimit = SK_ScalarMin;
1080 }
1081
1082 fIsFlipped = shader.isFlippedGrad();
1083 }
1084
1085 GR_DECLARE_EFFECT_TEST;
1086
1087 const CircleConicalInfo fInfo;
1088 SkScalar fTLimit;
1089 bool fIsFlipped;
1090
1091 typedef GrGradientEffect INHERITED;
1092 };
1093
1094 class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect {
1095 public:
1096 GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
1097 virtual ~GLCircleOutside2PtConicalEffect() {}
1098
1099 virtual void emitCode(GrGLShaderBuilder*,
1100 const GrDrawEffect&,
1101 EffectKey,
1102 const char* outputColor,
1103 const char* inputColor,
1104 const TransformedCoordsArray&,
1105 const TextureSamplerArray&) SK_OVERRIDE;
1106 virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVER RIDE;
1107
1108 static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
1109
1110 protected:
1111 UniformHandle fCenterUni;
1112 UniformHandle fParamUni;
1113
1114 const char* fVSVaryingName;
1115 const char* fFSVaryingName;
1116
1117 bool fIsFlipped;
1118
1119 // @{
1120 /// Values last uploaded as uniforms
1121
1122 SkScalar fCachedCenterX;
1123 SkScalar fCachedCenterY;
1124 SkScalar fCachedA;
1125 SkScalar fCachedB;
1126 SkScalar fCachedC;
1127 SkScalar fCachedTLimit;
1128
1129 // @}
1130
1131 private:
1132 typedef GrGLGradientEffect INHERITED;
1133
1134 };
1135
1136 const GrBackendEffectFactory& CircleOutside2PtConicalEffect::getFactory() const {
1137 return GrTBackendEffectFactory<CircleOutside2PtConicalEffect>::getInstance() ;
1138 }
1139
1140 GR_DEFINE_EFFECT_TEST(CircleOutside2PtConicalEffect);
1141
1142 GrEffectRef* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random,
1143 GrContext* context,
1144 const GrDrawTargetCaps&,
1145 GrTexture**) {
1146 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};
1147 SkScalar radius1 = random->nextUScalar1() + 0.0001; // make sure radius1 != 0
1148 SkPoint center2;
1149 SkScalar radius2;
1150 SkScalar diffLen;
1151 do {
1152 center2.set(random->nextUScalar1(), random->nextUScalar1());
1153 SkPoint diff = center2 - center1;
1154 diffLen = diff.length();
1155 // Below makes sure that circle one is not contained within circle two
1156 // and have radius2 >= radius to match sorting on cpu side
1157 radius2 = radius1 + random->nextRangeF(0.0, diffLen);
1158 // If the circles are identical the factory will give us an empty shader .
1159 } while (radius1 == radius2 && center1 == center2);
1160
1161 SkColor colors[kMaxRandomGradientColors];
1162 SkScalar stopsArray[kMaxRandomGradientColors];
1163 SkScalar* stops = stopsArray;
1164 SkShader::TileMode tm;
1165 int colorCount = RandomGradientParams(random, colors, &stops, &tm);
1166 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center 1, radius1,
1167 center 2, radius2,
1168 colors , stops, colorCount,
1169 tm));
1170 SkPaint paint;
1171 return shader->asNewEffect(context, paint);
1172 }
1173
1174 GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackend EffectFactory& factory,
1175 const GrDrawEff ect& drawEffect)
1176 : INHERITED(factory)
1177 , fVSVaryingName(NULL)
1178 , fFSVaryingName(NULL)
1179 , fCachedCenterX(SK_ScalarMax)
1180 , fCachedCenterY(SK_ScalarMax)
1181 , fCachedA(SK_ScalarMax)
1182 , fCachedB(SK_ScalarMax)
1183 , fCachedC(SK_ScalarMax)
1184 , fCachedTLimit(SK_ScalarMax) {
1185 const CircleOutside2PtConicalEffect& data = drawEffect.castEffect<CircleOuts ide2PtConicalEffect>();
1186 fIsFlipped = data.isFlipped();
1187 }
1188
1189 void GLCircleOutside2PtConicalEffect::emitCode(GrGLShaderBuilder* builder,
1190 const GrDrawEffect&,
1191 EffectKey key,
1192 const char* outputColor,
1193 const char* inputColor,
1194 const TransformedCoordsArray& coo rds,
1195 const TextureSamplerArray& sample rs) {
1196 this->emitUniforms(builder, key);
1197 fCenterUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
1198 kVec2f_GrSLType, "Conical2FSCenter");
1199 fParamUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
1200 kVec4f_GrSLType, "Conical2FSParams");
1201 SkString tName("t");
1202
1203 GrGLShaderVar center = builder->getUniformVariable(fCenterUni);
1204 // params.x = A
1205 // params.y = B
1206 // params.z = C
1207 GrGLShaderVar params = builder->getUniformVariable(fParamUni);
1208
1209 // if we have a vec3 from being in perspective, convert it to a vec2 first
1210 const char* coords2D;
1211 if (kVec3f_GrSLType == coords[0].type()) {
1212 builder->fsCodeAppendf("\tvec2 interpolants = vec2(%s.xy) / %s.z;\n",
1213 coords[0].c_str(), coords[0].c_str());
1214 coords2D = "interpolants";
1215 } else {
1216 coords2D = coords[0].c_str();
1217 }
1218
1219 // output will default to transparent black (we simply won't write anything
1220 // else to it if invalid, instead of discarding or returning prematurely)
1221 builder->fsCodeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
1222
1223 // p = coords2D
1224 // e = center end
1225 // r = radius end
1226 // A = dot(e, e) - r^2 + 2 * r - 1
1227 // B = (r -1) / A
1228 // C = 1 / A
1229 // d = dot(e, p) + B
1230 // t = d +/- sqrt(d^2 - A * dot(p, p) + C)
1231
1232 builder->fsCodeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D );
1233 builder->fsCodeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, cente r.c_str(), params.c_str());
1234 builder->fsCodeAppendf("\tfloat deter = d * d - %s.x * pDotp + %s.z;\n", par ams.c_str(), params.c_str());
1235
1236 // Must check to see if we flipped the circle order (to make sure start radi us < end radius)
1237 // If so we must also flip sign on sqrt
1238 if (!fIsFlipped) {
1239 builder->fsCodeAppendf("\tfloat %s = d + sqrt(deter);\n", tName.c_str()) ;
1240 } else {
1241 builder->fsCodeAppendf("\tfloat %s = d - sqrt(deter);\n", tName.c_str()) ;
1242 }
1243
1244 /*
1245 builder->fsCodeAppendf("\tfloat temp = -1.0 * min(deter, %s - %s.w);\n", tNa me.c_str(), params.c_str());
1246 builder->fsCodeAppend("\ttemp = clamp(temp, 0.0, 1.0);\n");
1247 builder->fsCodeAppend("\ttemp = ceil(temp);\n");
1248 this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, sample rs);
1249 builder->fsCodeAppendf("\t%s = (1.0 - temp) * %s;\n", outputColor, outputCol or);
1250 */
1251 builder->fsCodeAppendf("\tif (%s >= %s.w && deter >= 0.0) {\n", tName.c_str( ), params.c_str());
1252 builder->fsCodeAppend("\t\t");
1253 this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, sample rs);
1254 builder->fsCodeAppend("\t}\n");
1255 }
1256
1257 void GLCircleOutside2PtConicalEffect::setData(const GrGLUniformManager& uman,
1258 const GrDrawEffect& drawEffect) {
1259 INHERITED::setData(uman, drawEffect);
1260 const CircleOutside2PtConicalEffect& data = drawEffect.castEffect<CircleOuts ide2PtConicalEffect>();
1261 SkASSERT(data.isFlipped() == fIsFlipped);
1262 SkScalar centerX = data.centerX();
1263 SkScalar centerY = data.centerY();
1264 SkScalar A = data.A();
1265 SkScalar B = data.B();
1266 SkScalar C = data.C();
1267 SkScalar tLimit = data.tLimit();
1268
1269 if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
1270 fCachedA != A || fCachedB != B || fCachedC != C || fCachedTLimit != tLim it) {
1271
1272 uman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(centerY ));
1273 uman.set4f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarTo Float(C),
1274 SkScalarToFloat(tLimit));
1275
1276 fCachedCenterX = centerX;
1277 fCachedCenterY = centerY;
1278 fCachedA = A;
1279 fCachedB = B;
1280 fCachedC = C;
1281 fCachedTLimit = tLimit;
1282 }
1283 }
1284
1285 GrGLEffect::EffectKey GLCircleOutside2PtConicalEffect::GenKey(const GrDrawEffect & drawEffect,
1286 const GrGLCaps&) {
1287 enum {
1288 kIsFlipped = 1 << kBaseKeyBitCnt,
1289 };
1290
1291 EffectKey key = GenBaseGradientKey(drawEffect);
1292
1293 if (drawEffect.castEffect<CircleOutside2PtConicalEffect>().isFlipped()) {
1294 key |= kIsFlipped;
1295 }
1296 return key;
1297 }
1298
1299 //////////////////////////////////////////////////////////////////////////////
1300
400 GrEffectRef* Gr2PtConicalGradientEffect::Create(GrContext* ctx, 1301 GrEffectRef* Gr2PtConicalGradientEffect::Create(GrContext* ctx,
401 const SkTwoPointConicalGradient& shader, 1302 const SkTwoPointConicalGradient& shader,
402 SkShader::TileMode tm) { 1303 SkShader::TileMode tm) {
403
404 SkMatrix matrix; 1304 SkMatrix matrix;
405 if (!shader.getLocalMatrix().invert(&matrix)) { 1305 if (!shader.getLocalMatrix().invert(&matrix)) {
406 return NULL; 1306 return NULL;
407 } 1307 }
408 1308
409 set_matrix_default_conical(shader, &matrix); 1309 if (shader.getStartRadius() < kErrorTol) {
410 return Default2PtConicalEffect::Create(ctx, shader, matrix, tm); 1310 SkScalar focalX;
1311 ConicalType type = set_matrix_focal_conical(shader, &matrix, &focalX);
1312 if (type == kInside_ConicalType) {
1313 return FocalInside2PtConicalEffect::Create(ctx, shader, matrix, tm, focalX);
1314 } else if(type == kEdge_ConicalType) {
1315 set_matrix_edge_conical(shader, &matrix);
1316 return Edge2PtConicalEffect::Create(ctx, shader, matrix, tm);
1317 } else {
1318 return FocalOutside2PtConicalEffect::Create(ctx, shader, matrix, tm, focalX);
1319 }
1320 }
1321
1322 CircleConicalInfo info;
1323 ConicalType type = set_matrix_circle_conical(shader, &matrix, &info);
1324
1325 if (type == kInside_ConicalType) {
1326 return CircleInside2PtConicalEffect::Create(ctx, shader, matrix, tm, inf o);
1327 } else if (type == kEdge_ConicalType) {
1328 set_matrix_edge_conical(shader, &matrix);
bsalomon 2014/04/21 18:54:58 might be the browser extension but this looks doub
1329 return Edge2PtConicalEffect::Create(ctx, shader, matrix, tm);
1330 } else {
1331 return CircleOutside2PtConicalEffect::Create(ctx, shader, matrix, tm, in fo);
1332 }
411 } 1333 }
412 1334
413 #endif 1335 #endif
OLDNEW
« gm/gradients_2pt_conical.cpp ('K') | « gyp/gmslides.gypi ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698