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