OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2014 Google Inc. | 3 * Copyright 2014 Google Inc. |
4 * | 4 * |
5 * 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 |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 #include "SkTwoPointConicalGradient_gpu.h" | 9 #include "SkTwoPointConicalGradient_gpu.h" |
10 | 10 |
11 #include "SkTwoPointConicalGradient.h" | 11 #include "SkTwoPointConicalGradient.h" |
12 | 12 |
13 #if SK_SUPPORT_GPU | 13 #if SK_SUPPORT_GPU |
14 #include "GrTBackendEffectFactory.h" | 14 #include "GrTBackendProcessorFactory.h" |
15 #include "gl/builders/GrGLProgramBuilder.h" | 15 #include "gl/builders/GrGLProgramBuilder.h" |
16 // For brevity | 16 // For brevity |
17 typedef GrGLProgramDataManager::UniformHandle UniformHandle; | 17 typedef GrGLProgramDataManager::UniformHandle UniformHandle; |
18 | 18 |
19 static const SkScalar kErrorTol = 0.00001f; | 19 static const SkScalar kErrorTol = 0.00001f; |
20 static const SkScalar kEdgeErrorTol = 5.f * kErrorTol; | 20 static const SkScalar kEdgeErrorTol = 5.f * kErrorTol; |
21 | 21 |
22 /** | 22 /** |
23 * We have three general cases for 2pt conical gradients. First we always assume
that | 23 * We have three general cases for 2pt conical gradients. First we always assume
that |
24 * the start radius <= end radius. Our first case (kInside_) is when the start c
ircle | 24 * the start radius <= end radius. Our first case (kInside_) is when the start c
ircle |
(...skipping 28 matching lines...) Expand all Loading... |
53 SkScalarMul(invDiffLen, diff.fX)); | 53 SkScalarMul(invDiffLen, diff.fX)); |
54 invLMatrix->postConcat(rot); | 54 invLMatrix->postConcat(rot); |
55 } | 55 } |
56 } | 56 } |
57 | 57 |
58 class GLEdge2PtConicalEffect; | 58 class GLEdge2PtConicalEffect; |
59 | 59 |
60 class Edge2PtConicalEffect : public GrGradientEffect { | 60 class Edge2PtConicalEffect : public GrGradientEffect { |
61 public: | 61 public: |
62 | 62 |
63 static GrEffect* Create(GrContext* ctx, | 63 static GrFragmentProcessor* Create(GrContext* ctx, |
64 const SkTwoPointConicalGradient& shader, | 64 const SkTwoPointConicalGradient& shader, |
65 const SkMatrix& matrix, | 65 const SkMatrix& matrix, |
66 SkShader::TileMode tm) { | 66 SkShader::TileMode tm) { |
67 return SkNEW_ARGS(Edge2PtConicalEffect, (ctx, shader, matrix, tm)); | 67 return SkNEW_ARGS(Edge2PtConicalEffect, (ctx, shader, matrix, tm)); |
68 } | 68 } |
69 | 69 |
70 virtual ~Edge2PtConicalEffect() {} | 70 virtual ~Edge2PtConicalEffect() {} |
71 | 71 |
72 static const char* Name() { return "Two-Point Conical Gradient Edge Touching
"; } | 72 static const char* Name() { return "Two-Point Conical Gradient Edge Touching
"; } |
73 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; | 73 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE; |
74 | 74 |
75 // The radial gradient parameters can collapse to a linear (instead of quadr
atic) equation. | 75 // The radial gradient parameters can collapse to a linear (instead of quadr
atic) equation. |
76 SkScalar center() const { return fCenterX1; } | 76 SkScalar center() const { return fCenterX1; } |
77 SkScalar diffRadius() const { return fDiffRadius; } | 77 SkScalar diffRadius() const { return fDiffRadius; } |
78 SkScalar radius() const { return fRadius0; } | 78 SkScalar radius() const { return fRadius0; } |
79 | 79 |
80 typedef GLEdge2PtConicalEffect GLEffect; | 80 typedef GLEdge2PtConicalEffect GLProcessor; |
81 | 81 |
82 private: | 82 private: |
83 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { | 83 virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE { |
84 const Edge2PtConicalEffect& s = sBase.cast<Edge2PtConicalEffect>(); | 84 const Edge2PtConicalEffect& s = sBase.cast<Edge2PtConicalEffect>(); |
85 return (INHERITED::onIsEqual(sBase) && | 85 return (INHERITED::onIsEqual(sBase) && |
86 this->fCenterX1 == s.fCenterX1 && | 86 this->fCenterX1 == s.fCenterX1 && |
87 this->fRadius0 == s.fRadius0 && | 87 this->fRadius0 == s.fRadius0 && |
88 this->fDiffRadius == s.fDiffRadius); | 88 this->fDiffRadius == s.fDiffRadius); |
89 } | 89 } |
90 | 90 |
91 Edge2PtConicalEffect(GrContext* ctx, | 91 Edge2PtConicalEffect(GrContext* ctx, |
92 const SkTwoPointConicalGradient& shader, | 92 const SkTwoPointConicalGradient& shader, |
93 const SkMatrix& matrix, | 93 const SkMatrix& matrix, |
(...skipping 18 matching lines...) Expand all Loading... |
112 SkScalar r0dr = SkScalarMul(fRadius0, fDiffRadius); | 112 SkScalar r0dr = SkScalarMul(fRadius0, fDiffRadius); |
113 bMatrix[SkMatrix::kMScaleX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMat
rix::kMScaleX]) + | 113 bMatrix[SkMatrix::kMScaleX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMat
rix::kMScaleX]) + |
114 SkScalarMul(r0dr, bMatrix[SkMatrix::
kMPersp0])); | 114 SkScalarMul(r0dr, bMatrix[SkMatrix::
kMPersp0])); |
115 bMatrix[SkMatrix::kMSkewX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatr
ix::kMSkewX]) + | 115 bMatrix[SkMatrix::kMSkewX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatr
ix::kMSkewX]) + |
116 SkScalarMul(r0dr, bMatrix[SkMatrix::k
MPersp1])); | 116 SkScalarMul(r0dr, bMatrix[SkMatrix::k
MPersp1])); |
117 bMatrix[SkMatrix::kMTransX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMat
rix::kMTransX]) + | 117 bMatrix[SkMatrix::kMTransX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMat
rix::kMTransX]) + |
118 SkScalarMul(r0dr, bMatrix[SkMatrix::
kMPersp2])); | 118 SkScalarMul(r0dr, bMatrix[SkMatrix::
kMPersp2])); |
119 this->addCoordTransform(&fBTransform); | 119 this->addCoordTransform(&fBTransform); |
120 } | 120 } |
121 | 121 |
122 GR_DECLARE_EFFECT_TEST; | 122 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
123 | 123 |
124 // @{ | 124 // @{ |
125 // Cache of values - these can change arbitrarily, EXCEPT | 125 // Cache of values - these can change arbitrarily, EXCEPT |
126 // we shouldn't change between degenerate and non-degenerate?! | 126 // we shouldn't change between degenerate and non-degenerate?! |
127 | 127 |
128 GrCoordTransform fBTransform; | 128 GrCoordTransform fBTransform; |
129 SkScalar fCenterX1; | 129 SkScalar fCenterX1; |
130 SkScalar fRadius0; | 130 SkScalar fRadius0; |
131 SkScalar fDiffRadius; | 131 SkScalar fDiffRadius; |
132 | 132 |
133 // @} | 133 // @} |
134 | 134 |
135 typedef GrGradientEffect INHERITED; | 135 typedef GrGradientEffect INHERITED; |
136 }; | 136 }; |
137 | 137 |
138 class GLEdge2PtConicalEffect : public GrGLGradientEffect { | 138 class GLEdge2PtConicalEffect : public GrGLGradientEffect { |
139 public: | 139 public: |
140 GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect
&); | 140 GLEdge2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrPro
cessor&); |
141 virtual ~GLEdge2PtConicalEffect() { } | 141 virtual ~GLEdge2PtConicalEffect() { } |
142 | 142 |
143 virtual void emitCode(GrGLProgramBuilder*, | 143 virtual void emitCode(GrGLProgramBuilder*, |
144 const GrEffect&, | 144 const GrFragmentProcessor&, |
145 const GrEffectKey&, | 145 const GrProcessorKey&, |
146 const char* outputColor, | 146 const char* outputColor, |
147 const char* inputColor, | 147 const char* inputColor, |
148 const TransformedCoordsArray&, | 148 const TransformedCoordsArray&, |
149 const TextureSamplerArray&) SK_OVERRIDE; | 149 const TextureSamplerArray&) SK_OVERRIDE; |
150 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE; | 150 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
151 | 151 |
152 static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder
* b); | 152 static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyB
uilder* b); |
153 | 153 |
154 protected: | 154 protected: |
155 UniformHandle fParamUni; | 155 UniformHandle fParamUni; |
156 | 156 |
157 const char* fVSVaryingName; | 157 const char* fVSVaryingName; |
158 const char* fFSVaryingName; | 158 const char* fFSVaryingName; |
159 | 159 |
160 // @{ | 160 // @{ |
161 /// Values last uploaded as uniforms | 161 /// Values last uploaded as uniforms |
162 | 162 |
163 SkScalar fCachedRadius; | 163 SkScalar fCachedRadius; |
164 SkScalar fCachedDiffRadius; | 164 SkScalar fCachedDiffRadius; |
165 | 165 |
166 // @} | 166 // @} |
167 | 167 |
168 private: | 168 private: |
169 typedef GrGLGradientEffect INHERITED; | 169 typedef GrGLGradientEffect INHERITED; |
170 | 170 |
171 }; | 171 }; |
172 | 172 |
173 const GrBackendEffectFactory& Edge2PtConicalEffect::getFactory() const { | 173 const GrBackendFragmentProcessorFactory& Edge2PtConicalEffect::getFactory() cons
t { |
174 return GrTBackendEffectFactory<Edge2PtConicalEffect>::getInstance(); | 174 return GrTBackendFragmentProcessorFactory<Edge2PtConicalEffect>::getInstance
(); |
175 } | 175 } |
176 | 176 |
177 GR_DEFINE_EFFECT_TEST(Edge2PtConicalEffect); | 177 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Edge2PtConicalEffect); |
178 | 178 |
179 /* | 179 /* |
180 * All Two point conical gradient test create functions may occasionally create
edge case shaders | 180 * All Two point conical gradient test create functions may occasionally create
edge case shaders |
181 */ | 181 */ |
182 GrEffect* Edge2PtConicalEffect::TestCreate(SkRandom* random, | 182 GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(SkRandom* random, |
183 GrContext* context, | 183 GrContext* context, |
184 const GrDrawTargetCaps&, | 184 const GrDrawTargetCaps&, |
185 GrTexture**) { | 185 GrTexture**) { |
186 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; | 186 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; |
187 SkScalar radius1 = random->nextUScalar1(); | 187 SkScalar radius1 = random->nextUScalar1(); |
188 SkPoint center2; | 188 SkPoint center2; |
189 SkScalar radius2; | 189 SkScalar radius2; |
190 do { | 190 do { |
191 center2.set(random->nextUScalar1(), random->nextUScalar1()); | 191 center2.set(random->nextUScalar1(), random->nextUScalar1()); |
192 // If the circles are identical the factory will give us an empty shader
. | 192 // If the circles are identical the factory will give us an empty shader
. |
193 // This will happen if we pick identical centers | 193 // This will happen if we pick identical centers |
194 } while (center1 == center2); | 194 } while (center1 == center2); |
195 | 195 |
196 // Below makes sure that circle one is contained within circle two | 196 // Below makes sure that circle one is contained within circle two |
197 // and both circles are touching on an edge | 197 // and both circles are touching on an edge |
198 SkPoint diff = center2 - center1; | 198 SkPoint diff = center2 - center1; |
199 SkScalar diffLen = diff.length(); | 199 SkScalar diffLen = diff.length(); |
200 radius2 = radius1 + diffLen; | 200 radius2 = radius1 + diffLen; |
201 | 201 |
202 SkColor colors[kMaxRandomGradientColors]; | 202 SkColor colors[kMaxRandomGradientColors]; |
203 SkScalar stopsArray[kMaxRandomGradientColors]; | 203 SkScalar stopsArray[kMaxRandomGradientColors]; |
204 SkScalar* stops = stopsArray; | 204 SkScalar* stops = stopsArray; |
205 SkShader::TileMode tm; | 205 SkShader::TileMode tm; |
206 int colorCount = RandomGradientParams(random, colors, &stops, &tm); | 206 int colorCount = RandomGradientParams(random, colors, &stops, &tm); |
207 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center
1, radius1, | 207 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center
1, radius1, |
208 center
2, radius2, | 208 center
2, radius2, |
209 colors
, stops, colorCount, | 209 colors
, stops, colorCount, |
210 tm)); | 210 tm)); |
211 SkPaint paint; | 211 SkPaint paint; |
212 GrEffect* effect; | 212 GrFragmentProcessor* fp; |
213 GrColor paintColor; | 213 GrColor paintColor; |
214 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec
t)); | 214 SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor
, &fp)); |
215 return effect; | 215 return fp; |
216 } | 216 } |
217 | 217 |
218 GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendEffectFactory& fac
tory, | 218 GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendProcessorFactory&
factory, |
219 const GrEffect& effect) | 219 const GrProcessor&) |
220 : INHERITED(factory) | 220 : INHERITED(factory) |
221 , fVSVaryingName(NULL) | 221 , fVSVaryingName(NULL) |
222 , fFSVaryingName(NULL) | 222 , fFSVaryingName(NULL) |
223 , fCachedRadius(-SK_ScalarMax) | 223 , fCachedRadius(-SK_ScalarMax) |
224 , fCachedDiffRadius(-SK_ScalarMax) {} | 224 , fCachedDiffRadius(-SK_ScalarMax) {} |
225 | 225 |
226 void GLEdge2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, | 226 void GLEdge2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, |
227 const GrEffect&, | 227 const GrFragmentProcessor&, |
228 const GrEffectKey& key, | 228 const GrProcessorKey& key, |
229 const char* outputColor, | 229 const char* outputColor, |
230 const char* inputColor, | 230 const char* inputColor, |
231 const TransformedCoordsArray& coords, | 231 const TransformedCoordsArray& coords, |
232 const TextureSamplerArray& samplers) { | 232 const TextureSamplerArray& samplers) { |
233 uint32_t baseKey = key.get32(0); | 233 uint32_t baseKey = key.get32(0); |
234 this->emitUniforms(builder, baseKey); | 234 this->emitUniforms(builder, baseKey); |
235 fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibilit
y, | 235 fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibilit
y, |
236 kFloat_GrSLType, "Conical2FSParams", 3)
; | 236 kFloat_GrSLType, "Conical2FSParams", 3)
; |
237 | 237 |
238 SkString cName("c"); | 238 SkString cName("c"); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
275 | 275 |
276 // if r(t) > 0, then t will be the x coordinate | 276 // if r(t) > 0, then t will be the x coordinate |
277 fsBuilder->codeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(), | 277 fsBuilder->codeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(), |
278 p2.c_str(), p0.c_str()); | 278 p2.c_str(), p0.c_str()); |
279 fsBuilder->codeAppend("\t"); | 279 fsBuilder->codeAppend("\t"); |
280 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa
mplers); | 280 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa
mplers); |
281 fsBuilder->codeAppend("\t}\n"); | 281 fsBuilder->codeAppend("\t}\n"); |
282 } | 282 } |
283 | 283 |
284 void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman, | 284 void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman, |
285 const GrEffect& effect) { | 285 const GrProcessor& processor) { |
286 INHERITED::setData(pdman, effect); | 286 INHERITED::setData(pdman, processor); |
287 const Edge2PtConicalEffect& data = effect.cast<Edge2PtConicalEffect>(); | 287 const Edge2PtConicalEffect& data = processor.cast<Edge2PtConicalEffect>(); |
288 SkScalar radius0 = data.radius(); | 288 SkScalar radius0 = data.radius(); |
289 SkScalar diffRadius = data.diffRadius(); | 289 SkScalar diffRadius = data.diffRadius(); |
290 | 290 |
291 if (fCachedRadius != radius0 || | 291 if (fCachedRadius != radius0 || |
292 fCachedDiffRadius != diffRadius) { | 292 fCachedDiffRadius != diffRadius) { |
293 | 293 |
294 float values[3] = { | 294 float values[3] = { |
295 SkScalarToFloat(radius0), | 295 SkScalarToFloat(radius0), |
296 SkScalarToFloat(SkScalarMul(radius0, radius0)), | 296 SkScalarToFloat(SkScalarMul(radius0, radius0)), |
297 SkScalarToFloat(diffRadius) | 297 SkScalarToFloat(diffRadius) |
298 }; | 298 }; |
299 | 299 |
300 pdman.set1fv(fParamUni, 3, values); | 300 pdman.set1fv(fParamUni, 3, values); |
301 fCachedRadius = radius0; | 301 fCachedRadius = radius0; |
302 fCachedDiffRadius = diffRadius; | 302 fCachedDiffRadius = diffRadius; |
303 } | 303 } |
304 } | 304 } |
305 | 305 |
306 void GLEdge2PtConicalEffect::GenKey(const GrEffect& effect, | 306 void GLEdge2PtConicalEffect::GenKey(const GrProcessor& processor, |
307 const GrGLCaps&, GrEffectKeyBuilder* b) { | 307 const GrGLCaps&, GrProcessorKeyBuilder* b) { |
308 b->add32(GenBaseGradientKey(effect)); | 308 b->add32(GenBaseGradientKey(processor)); |
309 } | 309 } |
310 | 310 |
311 ////////////////////////////////////////////////////////////////////////////// | 311 ////////////////////////////////////////////////////////////////////////////// |
312 // Focal Conical Gradients | 312 // Focal Conical Gradients |
313 ////////////////////////////////////////////////////////////////////////////// | 313 ////////////////////////////////////////////////////////////////////////////// |
314 | 314 |
315 static ConicalType set_matrix_focal_conical(const SkTwoPointConicalGradient& sha
der, | 315 static ConicalType set_matrix_focal_conical(const SkTwoPointConicalGradient& sha
der, |
316 SkMatrix* invLMatrix, SkScalar* foca
lX) { | 316 SkMatrix* invLMatrix, SkScalar* foca
lX) { |
317 // Inverse of the current local matrix is passed in then, | 317 // Inverse of the current local matrix is passed in then, |
318 // translate, scale, and rotate such that endCircle is unit circle on x-axis
, | 318 // translate, scale, and rotate such that endCircle is unit circle on x-axis
, |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
368 return conicalType; | 368 return conicalType; |
369 } | 369 } |
370 | 370 |
371 ////////////////////////////////////////////////////////////////////////////// | 371 ////////////////////////////////////////////////////////////////////////////// |
372 | 372 |
373 class GLFocalOutside2PtConicalEffect; | 373 class GLFocalOutside2PtConicalEffect; |
374 | 374 |
375 class FocalOutside2PtConicalEffect : public GrGradientEffect { | 375 class FocalOutside2PtConicalEffect : public GrGradientEffect { |
376 public: | 376 public: |
377 | 377 |
378 static GrEffect* Create(GrContext* ctx, | 378 static GrFragmentProcessor* Create(GrContext* ctx, |
379 const SkTwoPointConicalGradient& shader, | 379 const SkTwoPointConicalGradient& shader, |
380 const SkMatrix& matrix, | 380 const SkMatrix& matrix, |
381 SkShader::TileMode tm, | 381 SkShader::TileMode tm, |
382 SkScalar focalX) { | 382 SkScalar focalX) { |
383 return SkNEW_ARGS(FocalOutside2PtConicalEffect, (ctx, shader, matrix, tm
, focalX)); | 383 return SkNEW_ARGS(FocalOutside2PtConicalEffect, (ctx, shader, matrix, tm
, focalX)); |
384 } | 384 } |
385 | 385 |
386 virtual ~FocalOutside2PtConicalEffect() { } | 386 virtual ~FocalOutside2PtConicalEffect() { } |
387 | 387 |
388 static const char* Name() { return "Two-Point Conical Gradient Focal Outside
"; } | 388 static const char* Name() { return "Two-Point Conical Gradient Focal Outside
"; } |
389 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; | 389 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE; |
390 | 390 |
391 bool isFlipped() const { return fIsFlipped; } | 391 bool isFlipped() const { return fIsFlipped; } |
392 SkScalar focal() const { return fFocalX; } | 392 SkScalar focal() const { return fFocalX; } |
393 | 393 |
394 typedef GLFocalOutside2PtConicalEffect GLEffect; | 394 typedef GLFocalOutside2PtConicalEffect GLProcessor; |
395 | 395 |
396 private: | 396 private: |
397 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { | 397 virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE { |
398 const FocalOutside2PtConicalEffect& s = sBase.cast<FocalOutside2PtConica
lEffect>(); | 398 const FocalOutside2PtConicalEffect& s = sBase.cast<FocalOutside2PtConica
lEffect>(); |
399 return (INHERITED::onIsEqual(sBase) && | 399 return (INHERITED::onIsEqual(sBase) && |
400 this->fFocalX == s.fFocalX && | 400 this->fFocalX == s.fFocalX && |
401 this->fIsFlipped == s.fIsFlipped); | 401 this->fIsFlipped == s.fIsFlipped); |
402 } | 402 } |
403 | 403 |
404 FocalOutside2PtConicalEffect(GrContext* ctx, | 404 FocalOutside2PtConicalEffect(GrContext* ctx, |
405 const SkTwoPointConicalGradient& shader, | 405 const SkTwoPointConicalGradient& shader, |
406 const SkMatrix& matrix, | 406 const SkMatrix& matrix, |
407 SkShader::TileMode tm, | 407 SkShader::TileMode tm, |
408 SkScalar focalX) | 408 SkScalar focalX) |
409 : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isF
lippedGrad()) {} | 409 : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isF
lippedGrad()) {} |
410 | 410 |
411 GR_DECLARE_EFFECT_TEST; | 411 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
412 | 412 |
413 SkScalar fFocalX; | 413 SkScalar fFocalX; |
414 bool fIsFlipped; | 414 bool fIsFlipped; |
415 | 415 |
416 typedef GrGradientEffect INHERITED; | 416 typedef GrGradientEffect INHERITED; |
417 }; | 417 }; |
418 | 418 |
419 class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect { | 419 class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect { |
420 public: | 420 public: |
421 GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const
GrEffect&); | 421 GLFocalOutside2PtConicalEffect(const GrBackendProcessorFactory& factory, con
st GrProcessor&); |
422 virtual ~GLFocalOutside2PtConicalEffect() { } | 422 virtual ~GLFocalOutside2PtConicalEffect() { } |
423 | 423 |
424 virtual void emitCode(GrGLProgramBuilder*, | 424 virtual void emitCode(GrGLProgramBuilder*, |
425 const GrEffect&, | 425 const GrFragmentProcessor&, |
426 const GrEffectKey&, | 426 const GrProcessorKey&, |
427 const char* outputColor, | 427 const char* outputColor, |
428 const char* inputColor, | 428 const char* inputColor, |
429 const TransformedCoordsArray&, | 429 const TransformedCoordsArray&, |
430 const TextureSamplerArray&) SK_OVERRIDE; | 430 const TextureSamplerArray&) SK_OVERRIDE; |
431 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE; | 431 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
432 | 432 |
433 static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder
* b); | 433 static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyB
uilder* b); |
434 | 434 |
435 protected: | 435 protected: |
436 UniformHandle fParamUni; | 436 UniformHandle fParamUni; |
437 | 437 |
438 const char* fVSVaryingName; | 438 const char* fVSVaryingName; |
439 const char* fFSVaryingName; | 439 const char* fFSVaryingName; |
440 | 440 |
441 bool fIsFlipped; | 441 bool fIsFlipped; |
442 | 442 |
443 // @{ | 443 // @{ |
444 /// Values last uploaded as uniforms | 444 /// Values last uploaded as uniforms |
445 | 445 |
446 SkScalar fCachedFocal; | 446 SkScalar fCachedFocal; |
447 | 447 |
448 // @} | 448 // @} |
449 | 449 |
450 private: | 450 private: |
451 typedef GrGLGradientEffect INHERITED; | 451 typedef GrGLGradientEffect INHERITED; |
452 | 452 |
453 }; | 453 }; |
454 | 454 |
455 const GrBackendEffectFactory& FocalOutside2PtConicalEffect::getFactory() const { | 455 const GrBackendFragmentProcessorFactory& FocalOutside2PtConicalEffect::getFactor
y() const { |
456 return GrTBackendEffectFactory<FocalOutside2PtConicalEffect>::getInstance(); | 456 return GrTBackendFragmentProcessorFactory<FocalOutside2PtConicalEffect>::get
Instance(); |
457 } | 457 } |
458 | 458 |
459 GR_DEFINE_EFFECT_TEST(FocalOutside2PtConicalEffect); | 459 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalOutside2PtConicalEffect); |
460 | 460 |
461 /* | 461 /* |
462 * All Two point conical gradient test create functions may occasionally create
edge case shaders | 462 * All Two point conical gradient test create functions may occasionally create
edge case shaders |
463 */ | 463 */ |
464 GrEffect* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random, | 464 GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random, |
465 GrContext* context, | 465 GrContext* context
, |
466 const GrDrawTargetCaps&, | 466 const GrDrawTarget
Caps&, |
467 GrTexture**) { | 467 GrTexture**) { |
468 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; | 468 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; |
469 SkScalar radius1 = 0.f; | 469 SkScalar radius1 = 0.f; |
470 SkPoint center2; | 470 SkPoint center2; |
471 SkScalar radius2; | 471 SkScalar radius2; |
472 do { | 472 do { |
473 center2.set(random->nextUScalar1(), random->nextUScalar1()); | 473 center2.set(random->nextUScalar1(), random->nextUScalar1()); |
474 // Need to make sure the centers are not the same or else focal point wi
ll be inside | 474 // Need to make sure the centers are not the same or else focal point wi
ll be inside |
475 } while (center1 == center2); | 475 } while (center1 == center2); |
476 SkPoint diff = center2 - center1; | 476 SkPoint diff = center2 - center1; |
477 SkScalar diffLen = diff.length(); | 477 SkScalar diffLen = diff.length(); |
478 // Below makes sure that the focal point is not contained within circle
two | 478 // Below makes sure that the focal point is not contained within circle
two |
479 radius2 = random->nextRangeF(0.f, diffLen); | 479 radius2 = random->nextRangeF(0.f, diffLen); |
480 | 480 |
481 SkColor colors[kMaxRandomGradientColors]; | 481 SkColor colors[kMaxRandomGradientColors]; |
482 SkScalar stopsArray[kMaxRandomGradientColors]; | 482 SkScalar stopsArray[kMaxRandomGradientColors]; |
483 SkScalar* stops = stopsArray; | 483 SkScalar* stops = stopsArray; |
484 SkShader::TileMode tm; | 484 SkShader::TileMode tm; |
485 int colorCount = RandomGradientParams(random, colors, &stops, &tm); | 485 int colorCount = RandomGradientParams(random, colors, &stops, &tm); |
486 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center
1, radius1, | 486 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center
1, radius1, |
487 center
2, radius2, | 487 center
2, radius2, |
488 colors
, stops, colorCount, | 488 colors
, stops, colorCount, |
489 tm)); | 489 tm)); |
490 SkPaint paint; | 490 SkPaint paint; |
491 GrEffect* effect; | 491 GrFragmentProcessor* effect; |
492 GrColor paintColor; | 492 GrColor paintColor; |
493 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec
t)); | 493 SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor
, &effect)); |
494 return effect; | 494 return effect; |
495 } | 495 } |
496 | 496 |
497 GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendEf
fectFactory& factory, | 497 GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendPr
ocessorFactory& factory, |
498 const GrEffect& e
ffect) | 498 const GrProcessor
& processor) |
499 : INHERITED(factory) | 499 : INHERITED(factory) |
500 , fVSVaryingName(NULL) | 500 , fVSVaryingName(NULL) |
501 , fFSVaryingName(NULL) | 501 , fFSVaryingName(NULL) |
502 , fCachedFocal(SK_ScalarMax) { | 502 , fCachedFocal(SK_ScalarMax) { |
503 const FocalOutside2PtConicalEffect& data = effect.cast<FocalOutside2PtConica
lEffect>(); | 503 const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtCon
icalEffect>(); |
504 fIsFlipped = data.isFlipped(); | 504 fIsFlipped = data.isFlipped(); |
505 } | 505 } |
506 | 506 |
507 void GLFocalOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, | 507 void GLFocalOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, |
508 const GrEffect&, | 508 const GrFragmentProcessor&, |
509 const GrEffectKey& key, | 509 const GrProcessorKey& key, |
510 const char* outputColor, | 510 const char* outputColor, |
511 const char* inputColor, | 511 const char* inputColor, |
512 const TransformedCoordsArray& coor
ds, | 512 const TransformedCoordsArray& coor
ds, |
513 const TextureSamplerArray& sampler
s) { | 513 const TextureSamplerArray& sampler
s) { |
514 uint32_t baseKey = key.get32(0); | 514 uint32_t baseKey = key.get32(0); |
515 this->emitUniforms(builder, baseKey); | 515 this->emitUniforms(builder, baseKey); |
516 fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibilit
y, | 516 fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibilit
y, |
517 kFloat_GrSLType, "Conical2FSParams", 2)
; | 517 kFloat_GrSLType, "Conical2FSParams", 2)
; |
518 SkString tName("t"); | 518 SkString tName("t"); |
519 SkString p0; // focalX | 519 SkString p0; // focalX |
(...skipping 27 matching lines...) Expand all Loading... |
547 coords2D, p0.c_str()); | 547 coords2D, p0.c_str()); |
548 } | 548 } |
549 | 549 |
550 fsBuilder->codeAppendf("\tif (%s >= 0.0 && d >= 0.0) {\n", tName.c_str()); | 550 fsBuilder->codeAppendf("\tif (%s >= 0.0 && d >= 0.0) {\n", tName.c_str()); |
551 fsBuilder->codeAppend("\t\t"); | 551 fsBuilder->codeAppend("\t\t"); |
552 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa
mplers); | 552 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa
mplers); |
553 fsBuilder->codeAppend("\t}\n"); | 553 fsBuilder->codeAppend("\t}\n"); |
554 } | 554 } |
555 | 555 |
556 void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman
, | 556 void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman
, |
557 const GrEffect& effect) { | 557 const GrProcessor& processor) { |
558 INHERITED::setData(pdman, effect); | 558 INHERITED::setData(pdman, processor); |
559 const FocalOutside2PtConicalEffect& data = effect.cast<FocalOutside2PtConica
lEffect>(); | 559 const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtCon
icalEffect>(); |
560 SkASSERT(data.isFlipped() == fIsFlipped); | 560 SkASSERT(data.isFlipped() == fIsFlipped); |
561 SkScalar focal = data.focal(); | 561 SkScalar focal = data.focal(); |
562 | 562 |
563 if (fCachedFocal != focal) { | 563 if (fCachedFocal != focal) { |
564 SkScalar oneMinus2F = 1.f - SkScalarMul(focal, focal); | 564 SkScalar oneMinus2F = 1.f - SkScalarMul(focal, focal); |
565 | 565 |
566 float values[2] = { | 566 float values[2] = { |
567 SkScalarToFloat(focal), | 567 SkScalarToFloat(focal), |
568 SkScalarToFloat(oneMinus2F), | 568 SkScalarToFloat(oneMinus2F), |
569 }; | 569 }; |
570 | 570 |
571 pdman.set1fv(fParamUni, 2, values); | 571 pdman.set1fv(fParamUni, 2, values); |
572 fCachedFocal = focal; | 572 fCachedFocal = focal; |
573 } | 573 } |
574 } | 574 } |
575 | 575 |
576 void GLFocalOutside2PtConicalEffect::GenKey(const GrEffect& effect, | 576 void GLFocalOutside2PtConicalEffect::GenKey(const GrProcessor& processor, |
577 const GrGLCaps&, GrEffectKeyBuilder*
b) { | 577 const GrGLCaps&, GrProcessorKeyBuild
er* b) { |
578 uint32_t* key = b->add32n(2); | 578 uint32_t* key = b->add32n(2); |
579 key[0] = GenBaseGradientKey(effect); | 579 key[0] = GenBaseGradientKey(processor); |
580 key[1] = effect.cast<FocalOutside2PtConicalEffect>().isFlipped(); | 580 key[1] = processor.cast<FocalOutside2PtConicalEffect>().isFlipped(); |
581 } | 581 } |
582 | 582 |
583 ////////////////////////////////////////////////////////////////////////////// | 583 ////////////////////////////////////////////////////////////////////////////// |
584 | 584 |
585 class GLFocalInside2PtConicalEffect; | 585 class GLFocalInside2PtConicalEffect; |
586 | 586 |
587 class FocalInside2PtConicalEffect : public GrGradientEffect { | 587 class FocalInside2PtConicalEffect : public GrGradientEffect { |
588 public: | 588 public: |
589 | 589 |
590 static GrEffect* Create(GrContext* ctx, | 590 static GrFragmentProcessor* Create(GrContext* ctx, |
591 const SkTwoPointConicalGradient& shader, | 591 const SkTwoPointConicalGradient& shader, |
592 const SkMatrix& matrix, | 592 const SkMatrix& matrix, |
593 SkShader::TileMode tm, | 593 SkShader::TileMode tm, |
594 SkScalar focalX) { | 594 SkScalar focalX) { |
595 return SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, shader, matrix, tm,
focalX)); | 595 return SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, shader, matrix, tm,
focalX)); |
596 } | 596 } |
597 | 597 |
598 virtual ~FocalInside2PtConicalEffect() {} | 598 virtual ~FocalInside2PtConicalEffect() {} |
599 | 599 |
600 static const char* Name() { return "Two-Point Conical Gradient Focal Inside"
; } | 600 static const char* Name() { return "Two-Point Conical Gradient Focal Inside"
; } |
601 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; | 601 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE; |
602 | 602 |
603 SkScalar focal() const { return fFocalX; } | 603 SkScalar focal() const { return fFocalX; } |
604 | 604 |
605 typedef GLFocalInside2PtConicalEffect GLEffect; | 605 typedef GLFocalInside2PtConicalEffect GLProcessor; |
606 | 606 |
607 private: | 607 private: |
608 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { | 608 virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE { |
609 const FocalInside2PtConicalEffect& s = sBase.cast<FocalInside2PtConicalE
ffect>(); | 609 const FocalInside2PtConicalEffect& s = sBase.cast<FocalInside2PtConicalE
ffect>(); |
610 return (INHERITED::onIsEqual(sBase) && | 610 return (INHERITED::onIsEqual(sBase) && |
611 this->fFocalX == s.fFocalX); | 611 this->fFocalX == s.fFocalX); |
612 } | 612 } |
613 | 613 |
614 FocalInside2PtConicalEffect(GrContext* ctx, | 614 FocalInside2PtConicalEffect(GrContext* ctx, |
615 const SkTwoPointConicalGradient& shader, | 615 const SkTwoPointConicalGradient& shader, |
616 const SkMatrix& matrix, | 616 const SkMatrix& matrix, |
617 SkShader::TileMode tm, | 617 SkShader::TileMode tm, |
618 SkScalar focalX) | 618 SkScalar focalX) |
619 : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {} | 619 : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {} |
620 | 620 |
621 GR_DECLARE_EFFECT_TEST; | 621 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
622 | 622 |
623 SkScalar fFocalX; | 623 SkScalar fFocalX; |
624 | 624 |
625 typedef GrGradientEffect INHERITED; | 625 typedef GrGradientEffect INHERITED; |
626 }; | 626 }; |
627 | 627 |
628 class GLFocalInside2PtConicalEffect : public GrGLGradientEffect { | 628 class GLFocalInside2PtConicalEffect : public GrGLGradientEffect { |
629 public: | 629 public: |
630 GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory, const G
rEffect&); | 630 GLFocalInside2PtConicalEffect(const GrBackendProcessorFactory& factory, cons
t GrProcessor&); |
631 virtual ~GLFocalInside2PtConicalEffect() {} | 631 virtual ~GLFocalInside2PtConicalEffect() {} |
632 | 632 |
633 virtual void emitCode(GrGLProgramBuilder*, | 633 virtual void emitCode(GrGLProgramBuilder*, |
634 const GrEffect&, | 634 const GrFragmentProcessor&, |
635 const GrEffectKey&, | 635 const GrProcessorKey&, |
636 const char* outputColor, | 636 const char* outputColor, |
637 const char* inputColor, | 637 const char* inputColor, |
638 const TransformedCoordsArray&, | 638 const TransformedCoordsArray&, |
639 const TextureSamplerArray&) SK_OVERRIDE; | 639 const TextureSamplerArray&) SK_OVERRIDE; |
640 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE; | 640 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
641 | 641 |
642 static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder
* b); | 642 static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyB
uilder* b); |
643 | 643 |
644 protected: | 644 protected: |
645 UniformHandle fFocalUni; | 645 UniformHandle fFocalUni; |
646 | 646 |
647 const char* fVSVaryingName; | 647 const char* fVSVaryingName; |
648 const char* fFSVaryingName; | 648 const char* fFSVaryingName; |
649 | 649 |
650 // @{ | 650 // @{ |
651 /// Values last uploaded as uniforms | 651 /// Values last uploaded as uniforms |
652 | 652 |
653 SkScalar fCachedFocal; | 653 SkScalar fCachedFocal; |
654 | 654 |
655 // @} | 655 // @} |
656 | 656 |
657 private: | 657 private: |
658 typedef GrGLGradientEffect INHERITED; | 658 typedef GrGLGradientEffect INHERITED; |
659 | 659 |
660 }; | 660 }; |
661 | 661 |
662 const GrBackendEffectFactory& FocalInside2PtConicalEffect::getFactory() const { | 662 const GrBackendFragmentProcessorFactory& FocalInside2PtConicalEffect::getFactory
() const { |
663 return GrTBackendEffectFactory<FocalInside2PtConicalEffect>::getInstance(); | 663 return GrTBackendFragmentProcessorFactory<FocalInside2PtConicalEffect>::getI
nstance(); |
664 } | 664 } |
665 | 665 |
666 GR_DEFINE_EFFECT_TEST(FocalInside2PtConicalEffect); | 666 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalInside2PtConicalEffect); |
667 | 667 |
668 /* | 668 /* |
669 * All Two point conical gradient test create functions may occasionally create
edge case shaders | 669 * All Two point conical gradient test create functions may occasionally create
edge case shaders |
670 */ | 670 */ |
671 GrEffect* FocalInside2PtConicalEffect::TestCreate(SkRandom* random, | 671 GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(SkRandom* random, |
672 GrContext* context, | 672 GrContext* context, |
673 const GrDrawTargetCaps&, | 673 const GrDrawTargetC
aps&, |
674 GrTexture**) { | 674 GrTexture**) { |
675 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; | 675 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; |
676 SkScalar radius1 = 0.f; | 676 SkScalar radius1 = 0.f; |
677 SkPoint center2; | 677 SkPoint center2; |
678 SkScalar radius2; | 678 SkScalar radius2; |
679 do { | 679 do { |
680 center2.set(random->nextUScalar1(), random->nextUScalar1()); | 680 center2.set(random->nextUScalar1(), random->nextUScalar1()); |
681 // Below makes sure radius2 is larger enouch such that the focal point | 681 // Below makes sure radius2 is larger enouch such that the focal point |
682 // is inside the end circle | 682 // is inside the end circle |
683 SkScalar increase = random->nextUScalar1(); | 683 SkScalar increase = random->nextUScalar1(); |
684 SkPoint diff = center2 - center1; | 684 SkPoint diff = center2 - center1; |
685 SkScalar diffLen = diff.length(); | 685 SkScalar diffLen = diff.length(); |
686 radius2 = diffLen + increase; | 686 radius2 = diffLen + increase; |
687 // If the circles are identical the factory will give us an empty shader
. | 687 // If the circles are identical the factory will give us an empty shader
. |
688 } while (radius1 == radius2 && center1 == center2); | 688 } while (radius1 == radius2 && center1 == center2); |
689 | 689 |
690 SkColor colors[kMaxRandomGradientColors]; | 690 SkColor colors[kMaxRandomGradientColors]; |
691 SkScalar stopsArray[kMaxRandomGradientColors]; | 691 SkScalar stopsArray[kMaxRandomGradientColors]; |
692 SkScalar* stops = stopsArray; | 692 SkScalar* stops = stopsArray; |
693 SkShader::TileMode tm; | 693 SkShader::TileMode tm; |
694 int colorCount = RandomGradientParams(random, colors, &stops, &tm); | 694 int colorCount = RandomGradientParams(random, colors, &stops, &tm); |
695 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center
1, radius1, | 695 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center
1, radius1, |
696 center
2, radius2, | 696 center
2, radius2, |
697 colors
, stops, colorCount, | 697 colors
, stops, colorCount, |
698 tm)); | 698 tm)); |
699 SkPaint paint; | 699 SkPaint paint; |
700 GrColor paintColor; | 700 GrColor paintColor; |
701 GrEffect* effect; | 701 GrFragmentProcessor* fp; |
702 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec
t)); | 702 SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor
, &fp)); |
703 return effect; | 703 return fp; |
704 } | 704 } |
705 | 705 |
706 GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendEffe
ctFactory& factory, | 706 GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendProc
essorFactory& factory, |
707 const GrEffect& eff
ect) | 707 const GrProcessor&) |
708 : INHERITED(factory) | 708 : INHERITED(factory) |
709 , fVSVaryingName(NULL) | 709 , fVSVaryingName(NULL) |
710 , fFSVaryingName(NULL) | 710 , fFSVaryingName(NULL) |
711 , fCachedFocal(SK_ScalarMax) {} | 711 , fCachedFocal(SK_ScalarMax) {} |
712 | 712 |
713 void GLFocalInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, | 713 void GLFocalInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, |
714 const GrEffect&, | 714 const GrFragmentProcessor&, |
715 const GrEffectKey& key, | 715 const GrProcessorKey& key, |
716 const char* outputColor, | 716 const char* outputColor, |
717 const char* inputColor, | 717 const char* inputColor, |
718 const TransformedCoordsArray& coord
s, | 718 const TransformedCoordsArray& coord
s, |
719 const TextureSamplerArray& samplers
) { | 719 const TextureSamplerArray& samplers
) { |
720 uint32_t baseKey = key.get32(0); | 720 uint32_t baseKey = key.get32(0); |
721 this->emitUniforms(builder, baseKey); | 721 this->emitUniforms(builder, baseKey); |
722 fFocalUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 722 fFocalUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
723 kFloat_GrSLType, "Conical2FSParams"); | 723 kFloat_GrSLType, "Conical2FSParams"); |
724 SkString tName("t"); | 724 SkString tName("t"); |
725 | 725 |
726 // this is the distance along x-axis from the end center to focal point in | 726 // this is the distance along x-axis from the end center to focal point in |
727 // transformed coordinates | 727 // transformed coordinates |
728 GrGLShaderVar focal = builder->getUniformVariable(fFocalUni); | 728 GrGLShaderVar focal = builder->getUniformVariable(fFocalUni); |
729 | 729 |
730 // if we have a vec3 from being in perspective, convert it to a vec2 first | 730 // if we have a vec3 from being in perspective, convert it to a vec2 first |
731 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 731 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
732 SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0); | 732 SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0); |
733 const char* coords2D = coords2DString.c_str(); | 733 const char* coords2D = coords2DString.c_str(); |
734 | 734 |
735 // t = p.x * focalX + length(p) | 735 // t = p.x * focalX + length(p) |
736 fsBuilder->codeAppendf("\tfloat %s = %s.x * %s + length(%s);\n", tName.c_st
r(), | 736 fsBuilder->codeAppendf("\tfloat %s = %s.x * %s + length(%s);\n", tName.c_st
r(), |
737 coords2D, focal.c_str(), coords2D); | 737 coords2D, focal.c_str(), coords2D); |
738 | 738 |
739 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa
mplers); | 739 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa
mplers); |
740 } | 740 } |
741 | 741 |
742 void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman, | 742 void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman, |
743 const GrEffect& effect) { | 743 const GrProcessor& processor) { |
744 INHERITED::setData(pdman, effect); | 744 INHERITED::setData(pdman, processor); |
745 const FocalInside2PtConicalEffect& data = effect.cast<FocalInside2PtConicalE
ffect>(); | 745 const FocalInside2PtConicalEffect& data = processor.cast<FocalInside2PtConic
alEffect>(); |
746 SkScalar focal = data.focal(); | 746 SkScalar focal = data.focal(); |
747 | 747 |
748 if (fCachedFocal != focal) { | 748 if (fCachedFocal != focal) { |
749 pdman.set1f(fFocalUni, SkScalarToFloat(focal)); | 749 pdman.set1f(fFocalUni, SkScalarToFloat(focal)); |
750 fCachedFocal = focal; | 750 fCachedFocal = focal; |
751 } | 751 } |
752 } | 752 } |
753 | 753 |
754 void GLFocalInside2PtConicalEffect::GenKey(const GrEffect& effect, | 754 void GLFocalInside2PtConicalEffect::GenKey(const GrProcessor& processor, |
755 const GrGLCaps&, GrEffectKeyBuilder*
b) { | 755 const GrGLCaps&, GrProcessorKeyBuilde
r* b) { |
756 b->add32(GenBaseGradientKey(effect)); | 756 b->add32(GenBaseGradientKey(processor)); |
757 } | 757 } |
758 | 758 |
759 ////////////////////////////////////////////////////////////////////////////// | 759 ////////////////////////////////////////////////////////////////////////////// |
760 // Circle Conical Gradients | 760 // Circle Conical Gradients |
761 ////////////////////////////////////////////////////////////////////////////// | 761 ////////////////////////////////////////////////////////////////////////////// |
762 | 762 |
763 struct CircleConicalInfo { | 763 struct CircleConicalInfo { |
764 SkPoint fCenterEnd; | 764 SkPoint fCenterEnd; |
765 SkScalar fA; | 765 SkScalar fA; |
766 SkScalar fB; | 766 SkScalar fB; |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
818 return kInside_ConicalType; | 818 return kInside_ConicalType; |
819 } | 819 } |
820 return kOutside_ConicalType; | 820 return kOutside_ConicalType; |
821 } | 821 } |
822 | 822 |
823 class GLCircleInside2PtConicalEffect; | 823 class GLCircleInside2PtConicalEffect; |
824 | 824 |
825 class CircleInside2PtConicalEffect : public GrGradientEffect { | 825 class CircleInside2PtConicalEffect : public GrGradientEffect { |
826 public: | 826 public: |
827 | 827 |
828 static GrEffect* Create(GrContext* ctx, | 828 static GrFragmentProcessor* Create(GrContext* ctx, |
829 const SkTwoPointConicalGradient& shader, | 829 const SkTwoPointConicalGradient& shader, |
830 const SkMatrix& matrix, | 830 const SkMatrix& matrix, |
831 SkShader::TileMode tm, | 831 SkShader::TileMode tm, |
832 const CircleConicalInfo& info) { | 832 const CircleConicalInfo& info) { |
833 return SkNEW_ARGS(CircleInside2PtConicalEffect, (ctx, shader, matrix, tm
, info)); | 833 return SkNEW_ARGS(CircleInside2PtConicalEffect, (ctx, shader, matrix, tm
, info)); |
834 } | 834 } |
835 | 835 |
836 virtual ~CircleInside2PtConicalEffect() {} | 836 virtual ~CircleInside2PtConicalEffect() {} |
837 | 837 |
838 static const char* Name() { return "Two-Point Conical Gradient Inside"; } | 838 static const char* Name() { return "Two-Point Conical Gradient Inside"; } |
839 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; | 839 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE; |
840 | 840 |
841 SkScalar centerX() const { return fInfo.fCenterEnd.fX; } | 841 SkScalar centerX() const { return fInfo.fCenterEnd.fX; } |
842 SkScalar centerY() const { return fInfo.fCenterEnd.fY; } | 842 SkScalar centerY() const { return fInfo.fCenterEnd.fY; } |
843 SkScalar A() const { return fInfo.fA; } | 843 SkScalar A() const { return fInfo.fA; } |
844 SkScalar B() const { return fInfo.fB; } | 844 SkScalar B() const { return fInfo.fB; } |
845 SkScalar C() const { return fInfo.fC; } | 845 SkScalar C() const { return fInfo.fC; } |
846 | 846 |
847 typedef GLCircleInside2PtConicalEffect GLEffect; | 847 typedef GLCircleInside2PtConicalEffect GLProcessor; |
848 | 848 |
849 private: | 849 private: |
850 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { | 850 virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE { |
851 const CircleInside2PtConicalEffect& s = sBase.cast<CircleInside2PtConica
lEffect>(); | 851 const CircleInside2PtConicalEffect& s = sBase.cast<CircleInside2PtConica
lEffect>(); |
852 return (INHERITED::onIsEqual(sBase) && | 852 return (INHERITED::onIsEqual(sBase) && |
853 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd && | 853 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd && |
854 this->fInfo.fA == s.fInfo.fA && | 854 this->fInfo.fA == s.fInfo.fA && |
855 this->fInfo.fB == s.fInfo.fB && | 855 this->fInfo.fB == s.fInfo.fB && |
856 this->fInfo.fC == s.fInfo.fC); | 856 this->fInfo.fC == s.fInfo.fC); |
857 } | 857 } |
858 | 858 |
859 CircleInside2PtConicalEffect(GrContext* ctx, | 859 CircleInside2PtConicalEffect(GrContext* ctx, |
860 const SkTwoPointConicalGradient& shader, | 860 const SkTwoPointConicalGradient& shader, |
861 const SkMatrix& matrix, | 861 const SkMatrix& matrix, |
862 SkShader::TileMode tm, | 862 SkShader::TileMode tm, |
863 const CircleConicalInfo& info) | 863 const CircleConicalInfo& info) |
864 : INHERITED(ctx, shader, matrix, tm), fInfo(info) {} | 864 : INHERITED(ctx, shader, matrix, tm), fInfo(info) {} |
865 | 865 |
866 GR_DECLARE_EFFECT_TEST; | 866 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
867 | 867 |
868 const CircleConicalInfo fInfo; | 868 const CircleConicalInfo fInfo; |
869 | 869 |
870 typedef GrGradientEffect INHERITED; | 870 typedef GrGradientEffect INHERITED; |
871 }; | 871 }; |
872 | 872 |
873 class GLCircleInside2PtConicalEffect : public GrGLGradientEffect { | 873 class GLCircleInside2PtConicalEffect : public GrGLGradientEffect { |
874 public: | 874 public: |
875 GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory, const
GrEffect&); | 875 GLCircleInside2PtConicalEffect(const GrBackendProcessorFactory& factory, con
st GrProcessor&); |
876 virtual ~GLCircleInside2PtConicalEffect() {} | 876 virtual ~GLCircleInside2PtConicalEffect() {} |
877 | 877 |
878 virtual void emitCode(GrGLProgramBuilder*, | 878 virtual void emitCode(GrGLProgramBuilder*, |
879 const GrEffect&, | 879 const GrFragmentProcessor&, |
880 const GrEffectKey&, | 880 const GrProcessorKey&, |
881 const char* outputColor, | 881 const char* outputColor, |
882 const char* inputColor, | 882 const char* inputColor, |
883 const TransformedCoordsArray&, | 883 const TransformedCoordsArray&, |
884 const TextureSamplerArray&) SK_OVERRIDE; | 884 const TextureSamplerArray&) SK_OVERRIDE; |
885 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE; | 885 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
886 | 886 |
887 static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder
* b); | 887 static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyB
uilder* b); |
888 | 888 |
889 protected: | 889 protected: |
890 UniformHandle fCenterUni; | 890 UniformHandle fCenterUni; |
891 UniformHandle fParamUni; | 891 UniformHandle fParamUni; |
892 | 892 |
893 const char* fVSVaryingName; | 893 const char* fVSVaryingName; |
894 const char* fFSVaryingName; | 894 const char* fFSVaryingName; |
895 | 895 |
896 // @{ | 896 // @{ |
897 /// Values last uploaded as uniforms | 897 /// Values last uploaded as uniforms |
898 | 898 |
899 SkScalar fCachedCenterX; | 899 SkScalar fCachedCenterX; |
900 SkScalar fCachedCenterY; | 900 SkScalar fCachedCenterY; |
901 SkScalar fCachedA; | 901 SkScalar fCachedA; |
902 SkScalar fCachedB; | 902 SkScalar fCachedB; |
903 SkScalar fCachedC; | 903 SkScalar fCachedC; |
904 | 904 |
905 // @} | 905 // @} |
906 | 906 |
907 private: | 907 private: |
908 typedef GrGLGradientEffect INHERITED; | 908 typedef GrGLGradientEffect INHERITED; |
909 | 909 |
910 }; | 910 }; |
911 | 911 |
912 const GrBackendEffectFactory& CircleInside2PtConicalEffect::getFactory() const { | 912 const GrBackendFragmentProcessorFactory& CircleInside2PtConicalEffect::getFactor
y() const { |
913 return GrTBackendEffectFactory<CircleInside2PtConicalEffect>::getInstance(); | 913 return GrTBackendFragmentProcessorFactory<CircleInside2PtConicalEffect>::get
Instance(); |
914 } | 914 } |
915 | 915 |
916 GR_DEFINE_EFFECT_TEST(CircleInside2PtConicalEffect); | 916 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleInside2PtConicalEffect); |
917 | 917 |
918 /* | 918 /* |
919 * All Two point conical gradient test create functions may occasionally create
edge case shaders | 919 * All Two point conical gradient test create functions may occasionally create
edge case shaders |
920 */ | 920 */ |
921 GrEffect* CircleInside2PtConicalEffect::TestCreate(SkRandom* random, | 921 GrFragmentProcessor* CircleInside2PtConicalEffect::TestCreate(SkRandom* random, |
922 GrContext* context, | 922 GrContext* context
, |
923 const GrDrawTargetCaps&, | 923 const GrDrawTarget
Caps&, |
924 GrTexture**) { | 924 GrTexture**) { |
925 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; | 925 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; |
926 SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 !=
0 | 926 SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 !=
0 |
927 SkPoint center2; | 927 SkPoint center2; |
928 SkScalar radius2; | 928 SkScalar radius2; |
929 do { | 929 do { |
930 center2.set(random->nextUScalar1(), random->nextUScalar1()); | 930 center2.set(random->nextUScalar1(), random->nextUScalar1()); |
931 // Below makes sure that circle one is contained within circle two | 931 // Below makes sure that circle one is contained within circle two |
932 SkScalar increase = random->nextUScalar1(); | 932 SkScalar increase = random->nextUScalar1(); |
933 SkPoint diff = center2 - center1; | 933 SkPoint diff = center2 - center1; |
934 SkScalar diffLen = diff.length(); | 934 SkScalar diffLen = diff.length(); |
935 radius2 = radius1 + diffLen + increase; | 935 radius2 = radius1 + diffLen + increase; |
936 // If the circles are identical the factory will give us an empty shader
. | 936 // If the circles are identical the factory will give us an empty shader
. |
937 } while (radius1 == radius2 && center1 == center2); | 937 } while (radius1 == radius2 && center1 == center2); |
938 | 938 |
939 SkColor colors[kMaxRandomGradientColors]; | 939 SkColor colors[kMaxRandomGradientColors]; |
940 SkScalar stopsArray[kMaxRandomGradientColors]; | 940 SkScalar stopsArray[kMaxRandomGradientColors]; |
941 SkScalar* stops = stopsArray; | 941 SkScalar* stops = stopsArray; |
942 SkShader::TileMode tm; | 942 SkShader::TileMode tm; |
943 int colorCount = RandomGradientParams(random, colors, &stops, &tm); | 943 int colorCount = RandomGradientParams(random, colors, &stops, &tm); |
944 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center
1, radius1, | 944 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center
1, radius1, |
945 center
2, radius2, | 945 center
2, radius2, |
946 colors
, stops, colorCount, | 946 colors
, stops, colorCount, |
947 tm)); | 947 tm)); |
948 SkPaint paint; | 948 SkPaint paint; |
949 GrColor paintColor; | 949 GrColor paintColor; |
950 GrEffect* effect; | 950 GrFragmentProcessor* processor; |
951 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec
t)); | 951 SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor
, &processor)); |
952 return effect; | 952 return processor; |
953 } | 953 } |
954 | 954 |
955 GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendEf
fectFactory& factory, | 955 GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendPr
ocessorFactory& factory, |
956 const GrEffect& e
ffect) | 956 const GrProcessor
& processor) |
957 : INHERITED(factory) | 957 : INHERITED(factory) |
958 , fVSVaryingName(NULL) | 958 , fVSVaryingName(NULL) |
959 , fFSVaryingName(NULL) | 959 , fFSVaryingName(NULL) |
960 , fCachedCenterX(SK_ScalarMax) | 960 , fCachedCenterX(SK_ScalarMax) |
961 , fCachedCenterY(SK_ScalarMax) | 961 , fCachedCenterY(SK_ScalarMax) |
962 , fCachedA(SK_ScalarMax) | 962 , fCachedA(SK_ScalarMax) |
963 , fCachedB(SK_ScalarMax) | 963 , fCachedB(SK_ScalarMax) |
964 , fCachedC(SK_ScalarMax) {} | 964 , fCachedC(SK_ScalarMax) {} |
965 | 965 |
966 void GLCircleInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, | 966 void GLCircleInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, |
967 const GrEffect&, | 967 const GrFragmentProcessor&, |
968 const GrEffectKey& key, | 968 const GrProcessorKey& key, |
969 const char* outputColor, | 969 const char* outputColor, |
970 const char* inputColor, | 970 const char* inputColor, |
971 const TransformedCoordsArray& coor
ds, | 971 const TransformedCoordsArray& coor
ds, |
972 const TextureSamplerArray& sampler
s) { | 972 const TextureSamplerArray& sampler
s) { |
973 uint32_t baseKey = key.get32(0); | 973 uint32_t baseKey = key.get32(0); |
974 this->emitUniforms(builder, baseKey); | 974 this->emitUniforms(builder, baseKey); |
975 fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 975 fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
976 kVec2f_GrSLType, "Conical2FSCenter"); | 976 kVec2f_GrSLType, "Conical2FSCenter"); |
977 fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 977 fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
978 kVec3f_GrSLType, "Conical2FSParams"); | 978 kVec3f_GrSLType, "Conical2FSParams"); |
(...skipping 21 matching lines...) Expand all Loading... |
1000 fsBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D
); | 1000 fsBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D
); |
1001 fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, cente
r.c_str(), | 1001 fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, cente
r.c_str(), |
1002 params.c_str()); | 1002 params.c_str()); |
1003 fsBuilder->codeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\
n", | 1003 fsBuilder->codeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\
n", |
1004 tName.c_str(), params.c_str(), params.c_str()); | 1004 tName.c_str(), params.c_str(), params.c_str()); |
1005 | 1005 |
1006 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa
mplers); | 1006 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa
mplers); |
1007 } | 1007 } |
1008 | 1008 |
1009 void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman
, | 1009 void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman
, |
1010 const GrEffect& effect) { | 1010 const GrProcessor& processor) { |
1011 INHERITED::setData(pdman, effect); | 1011 INHERITED::setData(pdman, processor); |
1012 const CircleInside2PtConicalEffect& data = effect.cast<CircleInside2PtConica
lEffect>(); | 1012 const CircleInside2PtConicalEffect& data = processor.cast<CircleInside2PtCon
icalEffect>(); |
1013 SkScalar centerX = data.centerX(); | 1013 SkScalar centerX = data.centerX(); |
1014 SkScalar centerY = data.centerY(); | 1014 SkScalar centerY = data.centerY(); |
1015 SkScalar A = data.A(); | 1015 SkScalar A = data.A(); |
1016 SkScalar B = data.B(); | 1016 SkScalar B = data.B(); |
1017 SkScalar C = data.C(); | 1017 SkScalar C = data.C(); |
1018 | 1018 |
1019 if (fCachedCenterX != centerX || fCachedCenterY != centerY || | 1019 if (fCachedCenterX != centerX || fCachedCenterY != centerY || |
1020 fCachedA != A || fCachedB != B || fCachedC != C) { | 1020 fCachedA != A || fCachedB != B || fCachedC != C) { |
1021 | 1021 |
1022 pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(center
Y)); | 1022 pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(center
Y)); |
1023 pdman.set3f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarT
oFloat(C)); | 1023 pdman.set3f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarT
oFloat(C)); |
1024 | 1024 |
1025 fCachedCenterX = centerX; | 1025 fCachedCenterX = centerX; |
1026 fCachedCenterY = centerY; | 1026 fCachedCenterY = centerY; |
1027 fCachedA = A; | 1027 fCachedA = A; |
1028 fCachedB = B; | 1028 fCachedB = B; |
1029 fCachedC = C; | 1029 fCachedC = C; |
1030 } | 1030 } |
1031 } | 1031 } |
1032 | 1032 |
1033 void GLCircleInside2PtConicalEffect::GenKey(const GrEffect& effect, | 1033 void GLCircleInside2PtConicalEffect::GenKey(const GrProcessor& processor, |
1034 const GrGLCaps&, GrEffectKeyBuilder*
b) { | 1034 const GrGLCaps&, GrProcessorKeyBuild
er* b) { |
1035 b->add32(GenBaseGradientKey(effect)); | 1035 b->add32(GenBaseGradientKey(processor)); |
1036 } | 1036 } |
1037 | 1037 |
1038 ////////////////////////////////////////////////////////////////////////////// | 1038 ////////////////////////////////////////////////////////////////////////////// |
1039 | 1039 |
1040 class GLCircleOutside2PtConicalEffect; | 1040 class GLCircleOutside2PtConicalEffect; |
1041 | 1041 |
1042 class CircleOutside2PtConicalEffect : public GrGradientEffect { | 1042 class CircleOutside2PtConicalEffect : public GrGradientEffect { |
1043 public: | 1043 public: |
1044 | 1044 |
1045 static GrEffect* Create(GrContext* ctx, | 1045 static GrFragmentProcessor* Create(GrContext* ctx, |
1046 const SkTwoPointConicalGradient& shader, | 1046 const SkTwoPointConicalGradient& shader, |
1047 const SkMatrix& matrix, | 1047 const SkMatrix& matrix, |
1048 SkShader::TileMode tm, | 1048 SkShader::TileMode tm, |
1049 const CircleConicalInfo& info) { | 1049 const CircleConicalInfo& info) { |
1050 return SkNEW_ARGS(CircleOutside2PtConicalEffect, (ctx, shader, matrix, t
m, info)); | 1050 return SkNEW_ARGS(CircleOutside2PtConicalEffect, (ctx, shader, matrix, t
m, info)); |
1051 } | 1051 } |
1052 | 1052 |
1053 virtual ~CircleOutside2PtConicalEffect() {} | 1053 virtual ~CircleOutside2PtConicalEffect() {} |
1054 | 1054 |
1055 static const char* Name() { return "Two-Point Conical Gradient Outside"; } | 1055 static const char* Name() { return "Two-Point Conical Gradient Outside"; } |
1056 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; | 1056 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE; |
1057 | 1057 |
1058 SkScalar centerX() const { return fInfo.fCenterEnd.fX; } | 1058 SkScalar centerX() const { return fInfo.fCenterEnd.fX; } |
1059 SkScalar centerY() const { return fInfo.fCenterEnd.fY; } | 1059 SkScalar centerY() const { return fInfo.fCenterEnd.fY; } |
1060 SkScalar A() const { return fInfo.fA; } | 1060 SkScalar A() const { return fInfo.fA; } |
1061 SkScalar B() const { return fInfo.fB; } | 1061 SkScalar B() const { return fInfo.fB; } |
1062 SkScalar C() const { return fInfo.fC; } | 1062 SkScalar C() const { return fInfo.fC; } |
1063 SkScalar tLimit() const { return fTLimit; } | 1063 SkScalar tLimit() const { return fTLimit; } |
1064 bool isFlipped() const { return fIsFlipped; } | 1064 bool isFlipped() const { return fIsFlipped; } |
1065 | 1065 |
1066 typedef GLCircleOutside2PtConicalEffect GLEffect; | 1066 typedef GLCircleOutside2PtConicalEffect GLProcessor; |
1067 | 1067 |
1068 private: | 1068 private: |
1069 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { | 1069 virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE { |
1070 const CircleOutside2PtConicalEffect& s = sBase.cast<CircleOutside2PtConi
calEffect>(); | 1070 const CircleOutside2PtConicalEffect& s = sBase.cast<CircleOutside2PtConi
calEffect>(); |
1071 return (INHERITED::onIsEqual(sBase) && | 1071 return (INHERITED::onIsEqual(sBase) && |
1072 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd && | 1072 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd && |
1073 this->fInfo.fA == s.fInfo.fA && | 1073 this->fInfo.fA == s.fInfo.fA && |
1074 this->fInfo.fB == s.fInfo.fB && | 1074 this->fInfo.fB == s.fInfo.fB && |
1075 this->fInfo.fC == s.fInfo.fC && | 1075 this->fInfo.fC == s.fInfo.fC && |
1076 this->fTLimit == s.fTLimit && | 1076 this->fTLimit == s.fTLimit && |
1077 this->fIsFlipped == s.fIsFlipped); | 1077 this->fIsFlipped == s.fIsFlipped); |
1078 } | 1078 } |
1079 | 1079 |
1080 CircleOutside2PtConicalEffect(GrContext* ctx, | 1080 CircleOutside2PtConicalEffect(GrContext* ctx, |
1081 const SkTwoPointConicalGradient& shader, | 1081 const SkTwoPointConicalGradient& shader, |
1082 const SkMatrix& matrix, | 1082 const SkMatrix& matrix, |
1083 SkShader::TileMode tm, | 1083 SkShader::TileMode tm, |
1084 const CircleConicalInfo& info) | 1084 const CircleConicalInfo& info) |
1085 : INHERITED(ctx, shader, matrix, tm), fInfo(info) { | 1085 : INHERITED(ctx, shader, matrix, tm), fInfo(info) { |
1086 if (shader.getStartRadius() != shader.getEndRadius()) { | 1086 if (shader.getStartRadius() != shader.getEndRadius()) { |
1087 fTLimit = SkScalarDiv(shader.getStartRadius(), | 1087 fTLimit = SkScalarDiv(shader.getStartRadius(), |
1088 (shader.getStartRadius() - shader.getEndRadius
())); | 1088 (shader.getStartRadius() - shader.getEndRadius
())); |
1089 } else { | 1089 } else { |
1090 fTLimit = SK_ScalarMin; | 1090 fTLimit = SK_ScalarMin; |
1091 } | 1091 } |
1092 | 1092 |
1093 fIsFlipped = shader.isFlippedGrad(); | 1093 fIsFlipped = shader.isFlippedGrad(); |
1094 } | 1094 } |
1095 | 1095 |
1096 GR_DECLARE_EFFECT_TEST; | 1096 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
1097 | 1097 |
1098 const CircleConicalInfo fInfo; | 1098 const CircleConicalInfo fInfo; |
1099 SkScalar fTLimit; | 1099 SkScalar fTLimit; |
1100 bool fIsFlipped; | 1100 bool fIsFlipped; |
1101 | 1101 |
1102 typedef GrGradientEffect INHERITED; | 1102 typedef GrGradientEffect INHERITED; |
1103 }; | 1103 }; |
1104 | 1104 |
1105 class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect { | 1105 class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect { |
1106 public: | 1106 public: |
1107 GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const
GrEffect&); | 1107 GLCircleOutside2PtConicalEffect(const GrBackendProcessorFactory&, const GrPr
ocessor&); |
1108 virtual ~GLCircleOutside2PtConicalEffect() {} | 1108 virtual ~GLCircleOutside2PtConicalEffect() {} |
1109 | 1109 |
1110 virtual void emitCode(GrGLProgramBuilder*, | 1110 virtual void emitCode(GrGLProgramBuilder*, |
1111 const GrEffect&, | 1111 const GrFragmentProcessor&, |
1112 const GrEffectKey&, | 1112 const GrProcessorKey&, |
1113 const char* outputColor, | 1113 const char* outputColor, |
1114 const char* inputColor, | 1114 const char* inputColor, |
1115 const TransformedCoordsArray&, | 1115 const TransformedCoordsArray&, |
1116 const TextureSamplerArray&) SK_OVERRIDE; | 1116 const TextureSamplerArray&) SK_OVERRIDE; |
1117 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE; | 1117 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
1118 | 1118 |
1119 static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder
* b); | 1119 static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyB
uilder* b); |
1120 | 1120 |
1121 protected: | 1121 protected: |
1122 UniformHandle fCenterUni; | 1122 UniformHandle fCenterUni; |
1123 UniformHandle fParamUni; | 1123 UniformHandle fParamUni; |
1124 | 1124 |
1125 const char* fVSVaryingName; | 1125 const char* fVSVaryingName; |
1126 const char* fFSVaryingName; | 1126 const char* fFSVaryingName; |
1127 | 1127 |
1128 bool fIsFlipped; | 1128 bool fIsFlipped; |
1129 | 1129 |
1130 // @{ | 1130 // @{ |
1131 /// Values last uploaded as uniforms | 1131 /// Values last uploaded as uniforms |
1132 | 1132 |
1133 SkScalar fCachedCenterX; | 1133 SkScalar fCachedCenterX; |
1134 SkScalar fCachedCenterY; | 1134 SkScalar fCachedCenterY; |
1135 SkScalar fCachedA; | 1135 SkScalar fCachedA; |
1136 SkScalar fCachedB; | 1136 SkScalar fCachedB; |
1137 SkScalar fCachedC; | 1137 SkScalar fCachedC; |
1138 SkScalar fCachedTLimit; | 1138 SkScalar fCachedTLimit; |
1139 | 1139 |
1140 // @} | 1140 // @} |
1141 | 1141 |
1142 private: | 1142 private: |
1143 typedef GrGLGradientEffect INHERITED; | 1143 typedef GrGLGradientEffect INHERITED; |
1144 | 1144 |
1145 }; | 1145 }; |
1146 | 1146 |
1147 const GrBackendEffectFactory& CircleOutside2PtConicalEffect::getFactory() const
{ | 1147 const GrBackendFragmentProcessorFactory& CircleOutside2PtConicalEffect::getFacto
ry() const { |
1148 return GrTBackendEffectFactory<CircleOutside2PtConicalEffect>::getInstance()
; | 1148 return GrTBackendFragmentProcessorFactory<CircleOutside2PtConicalEffect>::ge
tInstance(); |
1149 } | 1149 } |
1150 | 1150 |
1151 GR_DEFINE_EFFECT_TEST(CircleOutside2PtConicalEffect); | 1151 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleOutside2PtConicalEffect); |
1152 | 1152 |
1153 /* | 1153 /* |
1154 * All Two point conical gradient test create functions may occasionally create
edge case shaders | 1154 * All Two point conical gradient test create functions may occasionally create
edge case shaders |
1155 */ | 1155 */ |
1156 GrEffect* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random, | 1156 GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random, |
1157 GrContext* context, | 1157 GrContext* contex
t, |
1158 const GrDrawTargetCaps&, | 1158 const GrDrawTarge
tCaps&, |
1159 GrTexture**) { | 1159 GrTexture**) { |
1160 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; | 1160 SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; |
1161 SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 !=
0 | 1161 SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 !=
0 |
1162 SkPoint center2; | 1162 SkPoint center2; |
1163 SkScalar radius2; | 1163 SkScalar radius2; |
1164 SkScalar diffLen; | 1164 SkScalar diffLen; |
1165 do { | 1165 do { |
1166 center2.set(random->nextUScalar1(), random->nextUScalar1()); | 1166 center2.set(random->nextUScalar1(), random->nextUScalar1()); |
1167 // If the circles share a center than we can't be in the outside case | 1167 // If the circles share a center than we can't be in the outside case |
1168 } while (center1 == center2); | 1168 } while (center1 == center2); |
1169 SkPoint diff = center2 - center1; | 1169 SkPoint diff = center2 - center1; |
1170 diffLen = diff.length(); | 1170 diffLen = diff.length(); |
1171 // Below makes sure that circle one is not contained within circle two | 1171 // Below makes sure that circle one is not contained within circle two |
1172 // and have radius2 >= radius to match sorting on cpu side | 1172 // and have radius2 >= radius to match sorting on cpu side |
1173 radius2 = radius1 + random->nextRangeF(0.f, diffLen); | 1173 radius2 = radius1 + random->nextRangeF(0.f, diffLen); |
1174 | 1174 |
1175 SkColor colors[kMaxRandomGradientColors]; | 1175 SkColor colors[kMaxRandomGradientColors]; |
1176 SkScalar stopsArray[kMaxRandomGradientColors]; | 1176 SkScalar stopsArray[kMaxRandomGradientColors]; |
1177 SkScalar* stops = stopsArray; | 1177 SkScalar* stops = stopsArray; |
1178 SkShader::TileMode tm; | 1178 SkShader::TileMode tm; |
1179 int colorCount = RandomGradientParams(random, colors, &stops, &tm); | 1179 int colorCount = RandomGradientParams(random, colors, &stops, &tm); |
1180 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center
1, radius1, | 1180 SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center
1, radius1, |
1181 center
2, radius2, | 1181 center
2, radius2, |
1182 colors
, stops, colorCount, | 1182 colors
, stops, colorCount, |
1183 tm)); | 1183 tm)); |
1184 SkPaint paint; | 1184 SkPaint paint; |
1185 GrColor paintColor; | 1185 GrColor paintColor; |
1186 GrEffect* effect; | 1186 GrFragmentProcessor* processor; |
1187 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec
t)); | 1187 SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor
, &processor)); |
1188 return effect; | 1188 return processor; |
1189 } | 1189 } |
1190 | 1190 |
1191 GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackend
EffectFactory& factory, | 1191 GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackend
ProcessorFactory& factory, |
1192 const GrEffect&
effect) | 1192 const GrProcess
or& processor) |
1193 : INHERITED(factory) | 1193 : INHERITED(factory) |
1194 , fVSVaryingName(NULL) | 1194 , fVSVaryingName(NULL) |
1195 , fFSVaryingName(NULL) | 1195 , fFSVaryingName(NULL) |
1196 , fCachedCenterX(SK_ScalarMax) | 1196 , fCachedCenterX(SK_ScalarMax) |
1197 , fCachedCenterY(SK_ScalarMax) | 1197 , fCachedCenterY(SK_ScalarMax) |
1198 , fCachedA(SK_ScalarMax) | 1198 , fCachedA(SK_ScalarMax) |
1199 , fCachedB(SK_ScalarMax) | 1199 , fCachedB(SK_ScalarMax) |
1200 , fCachedC(SK_ScalarMax) | 1200 , fCachedC(SK_ScalarMax) |
1201 , fCachedTLimit(SK_ScalarMax) { | 1201 , fCachedTLimit(SK_ScalarMax) { |
1202 const CircleOutside2PtConicalEffect& data = effect.cast<CircleOutside2PtConi
calEffect>(); | 1202 const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtC
onicalEffect>(); |
1203 fIsFlipped = data.isFlipped(); | 1203 fIsFlipped = data.isFlipped(); |
1204 } | 1204 } |
1205 | 1205 |
1206 void GLCircleOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, | 1206 void GLCircleOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, |
1207 const GrEffect&, | 1207 const GrFragmentProcessor&, |
1208 const GrEffectKey& key, | 1208 const GrProcessorKey& key, |
1209 const char* outputColor, | 1209 const char* outputColor, |
1210 const char* inputColor, | 1210 const char* inputColor, |
1211 const TransformedCoordsArray& coo
rds, | 1211 const TransformedCoordsArray& coo
rds, |
1212 const TextureSamplerArray& sample
rs) { | 1212 const TextureSamplerArray& sample
rs) { |
1213 uint32_t baseKey = key.get32(0); | 1213 uint32_t baseKey = key.get32(0); |
1214 this->emitUniforms(builder, baseKey); | 1214 this->emitUniforms(builder, baseKey); |
1215 fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1215 fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
1216 kVec2f_GrSLType, "Conical2FSCenter"); | 1216 kVec2f_GrSLType, "Conical2FSCenter"); |
1217 fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 1217 fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
1218 kVec4f_GrSLType, "Conical2FSParams"); | 1218 kVec4f_GrSLType, "Conical2FSParams"); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1256 fsBuilder->codeAppendf("\tfloat %s = d - sqrt(deter);\n", tName.c_str())
; | 1256 fsBuilder->codeAppendf("\tfloat %s = d - sqrt(deter);\n", tName.c_str())
; |
1257 } | 1257 } |
1258 | 1258 |
1259 fsBuilder->codeAppendf("\tif (%s >= %s.w && deter >= 0.0) {\n", tName.c_str(
), params.c_str()); | 1259 fsBuilder->codeAppendf("\tif (%s >= %s.w && deter >= 0.0) {\n", tName.c_str(
), params.c_str()); |
1260 fsBuilder->codeAppend("\t\t"); | 1260 fsBuilder->codeAppend("\t\t"); |
1261 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa
mplers); | 1261 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa
mplers); |
1262 fsBuilder->codeAppend("\t}\n"); | 1262 fsBuilder->codeAppend("\t}\n"); |
1263 } | 1263 } |
1264 | 1264 |
1265 void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdma
n, | 1265 void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdma
n, |
1266 const GrEffect& effect) { | 1266 const GrProcessor& processor) { |
1267 INHERITED::setData(pdman, effect); | 1267 INHERITED::setData(pdman, processor); |
1268 const CircleOutside2PtConicalEffect& data = effect.cast<CircleOutside2PtConi
calEffect>(); | 1268 const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtC
onicalEffect>(); |
1269 SkASSERT(data.isFlipped() == fIsFlipped); | 1269 SkASSERT(data.isFlipped() == fIsFlipped); |
1270 SkScalar centerX = data.centerX(); | 1270 SkScalar centerX = data.centerX(); |
1271 SkScalar centerY = data.centerY(); | 1271 SkScalar centerY = data.centerY(); |
1272 SkScalar A = data.A(); | 1272 SkScalar A = data.A(); |
1273 SkScalar B = data.B(); | 1273 SkScalar B = data.B(); |
1274 SkScalar C = data.C(); | 1274 SkScalar C = data.C(); |
1275 SkScalar tLimit = data.tLimit(); | 1275 SkScalar tLimit = data.tLimit(); |
1276 | 1276 |
1277 if (fCachedCenterX != centerX || fCachedCenterY != centerY || | 1277 if (fCachedCenterX != centerX || fCachedCenterY != centerY || |
1278 fCachedA != A || fCachedB != B || fCachedC != C || fCachedTLimit != tLim
it) { | 1278 fCachedA != A || fCachedB != B || fCachedC != C || fCachedTLimit != tLim
it) { |
1279 | 1279 |
1280 pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(center
Y)); | 1280 pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(center
Y)); |
1281 pdman.set4f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarT
oFloat(C), | 1281 pdman.set4f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarT
oFloat(C), |
1282 SkScalarToFloat(tLimit)); | 1282 SkScalarToFloat(tLimit)); |
1283 | 1283 |
1284 fCachedCenterX = centerX; | 1284 fCachedCenterX = centerX; |
1285 fCachedCenterY = centerY; | 1285 fCachedCenterY = centerY; |
1286 fCachedA = A; | 1286 fCachedA = A; |
1287 fCachedB = B; | 1287 fCachedB = B; |
1288 fCachedC = C; | 1288 fCachedC = C; |
1289 fCachedTLimit = tLimit; | 1289 fCachedTLimit = tLimit; |
1290 } | 1290 } |
1291 } | 1291 } |
1292 | 1292 |
1293 void GLCircleOutside2PtConicalEffect::GenKey(const GrEffect& effect, | 1293 void GLCircleOutside2PtConicalEffect::GenKey(const GrProcessor& processor, |
1294 const GrGLCaps&, GrEffectKeyBuilder
* b) { | 1294 const GrGLCaps&, GrProcessorKeyBuil
der* b) { |
1295 uint32_t* key = b->add32n(2); | 1295 uint32_t* key = b->add32n(2); |
1296 key[0] = GenBaseGradientKey(effect); | 1296 key[0] = GenBaseGradientKey(processor); |
1297 key[1] = effect.cast<CircleOutside2PtConicalEffect>().isFlipped(); | 1297 key[1] = processor.cast<CircleOutside2PtConicalEffect>().isFlipped(); |
1298 } | 1298 } |
1299 | 1299 |
1300 ////////////////////////////////////////////////////////////////////////////// | 1300 ////////////////////////////////////////////////////////////////////////////// |
1301 | 1301 |
1302 GrEffect* Gr2PtConicalGradientEffect::Create(GrContext* ctx, | 1302 GrFragmentProcessor* Gr2PtConicalGradientEffect::Create(GrContext* ctx, |
1303 const SkTwoPointConicalGradient& sh
ader, | 1303 const SkTwoPointConicalG
radient& shader, |
1304 SkShader::TileMode tm, | 1304 SkShader::TileMode tm, |
1305 const SkMatrix* localMatrix) { | 1305 const SkMatrix* localMat
rix) { |
1306 SkMatrix matrix; | 1306 SkMatrix matrix; |
1307 if (!shader.getLocalMatrix().invert(&matrix)) { | 1307 if (!shader.getLocalMatrix().invert(&matrix)) { |
1308 return NULL; | 1308 return NULL; |
1309 } | 1309 } |
1310 if (localMatrix) { | 1310 if (localMatrix) { |
1311 SkMatrix inv; | 1311 SkMatrix inv; |
1312 if (!localMatrix->invert(&inv)) { | 1312 if (!localMatrix->invert(&inv)) { |
1313 return NULL; | 1313 return NULL; |
1314 } | 1314 } |
1315 matrix.postConcat(inv); | 1315 matrix.postConcat(inv); |
(...skipping 19 matching lines...) Expand all Loading... |
1335 return CircleInside2PtConicalEffect::Create(ctx, shader, matrix, tm, inf
o); | 1335 return CircleInside2PtConicalEffect::Create(ctx, shader, matrix, tm, inf
o); |
1336 } else if (type == kEdge_ConicalType) { | 1336 } else if (type == kEdge_ConicalType) { |
1337 set_matrix_edge_conical(shader, &matrix); | 1337 set_matrix_edge_conical(shader, &matrix); |
1338 return Edge2PtConicalEffect::Create(ctx, shader, matrix, tm); | 1338 return Edge2PtConicalEffect::Create(ctx, shader, matrix, tm); |
1339 } else { | 1339 } else { |
1340 return CircleOutside2PtConicalEffect::Create(ctx, shader, matrix, tm, in
fo); | 1340 return CircleOutside2PtConicalEffect::Create(ctx, shader, matrix, tm, in
fo); |
1341 } | 1341 } |
1342 } | 1342 } |
1343 | 1343 |
1344 #endif | 1344 #endif |
OLD | NEW |