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

Side by Side Diff: src/gpu/effects/GrBezierEffect.cpp

Issue 571163002: removing GrDrawEffect (Closed) Base URL: https://skia.googlesource.com/skia.git@gp3
Patch Set: rebase after revert Created 6 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/gpu/GrOvalRenderer.cpp ('k') | src/gpu/effects/GrBicubicEffect.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright 2013 Google Inc. 2 * Copyright 2013 Google Inc.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license that can be 4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file. 5 * found in the LICENSE file.
6 */ 6 */
7 7
8 #include "gl/builders/GrGLProgramBuilder.h" 8 #include "gl/builders/GrGLProgramBuilder.h"
9 #include "GrBezierEffect.h" 9 #include "GrBezierEffect.h"
10 10
11 #include "gl/GrGLEffect.h" 11 #include "gl/GrGLEffect.h"
12 #include "gl/GrGLSL.h" 12 #include "gl/GrGLSL.h"
13 #include "gl/GrGLGeometryProcessor.h" 13 #include "gl/GrGLGeometryProcessor.h"
14 #include "GrTBackendEffectFactory.h" 14 #include "GrTBackendEffectFactory.h"
15 15
16 class GrGLConicEffect : public GrGLGeometryProcessor { 16 class GrGLConicEffect : public GrGLGeometryProcessor {
17 public: 17 public:
18 GrGLConicEffect(const GrBackendEffectFactory&, const GrDrawEffect&); 18 GrGLConicEffect(const GrBackendEffectFactory&, const GrEffect&);
19 19
20 virtual void emitCode(GrGLFullProgramBuilder* builder, 20 virtual void emitCode(GrGLFullProgramBuilder* builder,
21 const GrDrawEffect& drawEffect, 21 const GrEffect& effect,
22 const GrEffectKey& key, 22 const GrEffectKey& key,
23 const char* outputColor, 23 const char* outputColor,
24 const char* inputColor, 24 const char* inputColor,
25 const TransformedCoordsArray&, 25 const TransformedCoordsArray&,
26 const TextureSamplerArray&) SK_OVERRIDE; 26 const TextureSamplerArray&) SK_OVERRIDE;
27 27
28 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB uilder*); 28 static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuild er*);
29 29
30 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_ OVERRIDE {} 30 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER RIDE {}
31 31
32 private: 32 private:
33 GrEffectEdgeType fEdgeType; 33 GrEffectEdgeType fEdgeType;
34 34
35 typedef GrGLGeometryProcessor INHERITED; 35 typedef GrGLGeometryProcessor INHERITED;
36 }; 36 };
37 37
38 GrGLConicEffect::GrGLConicEffect(const GrBackendEffectFactory& factory, 38 GrGLConicEffect::GrGLConicEffect(const GrBackendEffectFactory& factory,
39 const GrDrawEffect& drawEffect) 39 const GrEffect& effect)
40 : INHERITED (factory) { 40 : INHERITED (factory) {
41 const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>(); 41 const GrConicEffect& ce = effect.cast<GrConicEffect>();
42 fEdgeType = ce.getEdgeType(); 42 fEdgeType = ce.getEdgeType();
43 } 43 }
44 44
45 void GrGLConicEffect::emitCode(GrGLFullProgramBuilder* builder, 45 void GrGLConicEffect::emitCode(GrGLFullProgramBuilder* builder,
46 const GrDrawEffect& drawEffect, 46 const GrEffect& effect,
47 const GrEffectKey& key, 47 const GrEffectKey& key,
48 const char* outputColor, 48 const char* outputColor,
49 const char* inputColor, 49 const char* inputColor,
50 const TransformedCoordsArray&, 50 const TransformedCoordsArray&,
51 const TextureSamplerArray& samplers) { 51 const TextureSamplerArray& samplers) {
52 const char *vsName, *fsName; 52 const char *vsName, *fsName;
53 53
54 builder->addVarying(kVec4f_GrSLType, "ConicCoeffs", 54 builder->addVarying(kVec4f_GrSLType, "ConicCoeffs",
55 &vsName, &fsName); 55 &vsName, &fsName);
56 56
57 const GrShaderVar& inConicCoeffs = drawEffect.castEffect<GrConicEffect>().in ConicCoeffs(); 57 const GrShaderVar& inConicCoeffs = effect.cast<GrConicEffect>().inConicCoeff s();
58 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); 58 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
59 vsBuilder->codeAppendf("%s = %s;", vsName, inConicCoeffs.c_str()); 59 vsBuilder->codeAppendf("%s = %s;", vsName, inConicCoeffs.c_str());
60 60
61 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); 61 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
62 fsBuilder->codeAppend("float edgeAlpha;"); 62 fsBuilder->codeAppend("float edgeAlpha;");
63 63
64 switch (fEdgeType) { 64 switch (fEdgeType) {
65 case kHairlineAA_GrEffectEdgeType: { 65 case kHairlineAA_GrEffectEdgeType: {
66 SkAssertResult(fsBuilder->enableFeature( 66 SkAssertResult(fsBuilder->enableFeature(
67 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature) ); 67 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature) );
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
112 break; 112 break;
113 } 113 }
114 default: 114 default:
115 SkFAIL("Shouldn't get here"); 115 SkFAIL("Shouldn't get here");
116 } 116 }
117 117
118 fsBuilder->codeAppendf("%s = %s;", outputColor, 118 fsBuilder->codeAppendf("%s = %s;", outputColor,
119 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")). c_str()); 119 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")). c_str());
120 } 120 }
121 121
122 void GrGLConicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, 122 void GrGLConicEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
123 GrEffectKeyBuilder* b) { 123 GrEffectKeyBuilder* b) {
124 const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>(); 124 const GrConicEffect& ce = effect.cast<GrConicEffect>();
125 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; 125 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
126 b->add32(key); 126 b->add32(key);
127 } 127 }
128 128
129 ////////////////////////////////////////////////////////////////////////////// 129 //////////////////////////////////////////////////////////////////////////////
130 130
131 GrConicEffect::~GrConicEffect() {} 131 GrConicEffect::~GrConicEffect() {}
132 132
133 const GrBackendEffectFactory& GrConicEffect::getFactory() const { 133 const GrBackendEffectFactory& GrConicEffect::getFactory() const {
134 return GrTBackendEffectFactory<GrConicEffect>::getInstance(); 134 return GrTBackendEffectFactory<GrConicEffect>::getInstance();
135 } 135 }
136 136
137 GrConicEffect::GrConicEffect(GrEffectEdgeType edgeType) 137 GrConicEffect::GrConicEffect(GrEffectEdgeType edgeType)
138 : fEdgeType(edgeType) 138 : fEdgeType(edgeType)
139 , fInConicCoeffs(this->addVertexAttrib(GrShaderVar("inConicCoeffs", 139 , fInConicCoeffs(this->addVertexAttrib(GrShaderVar("inConicCoeffs",
140 kVec4f_GrSLType, 140 kVec4f_GrSLType,
141 GrShaderVar::kAttribute_T ypeModifier))) { 141 GrShaderVar::kAttribute_T ypeModifier))) {
142 } 142 }
143 143
144 bool GrConicEffect::onIsEqual(const GrEffect& other) const { 144 bool GrConicEffect::onIsEqual(const GrEffect& other) const {
145 const GrConicEffect& ce = CastEffect<GrConicEffect>(other); 145 const GrConicEffect& ce = other.cast<GrConicEffect>();
146 return (ce.fEdgeType == fEdgeType); 146 return (ce.fEdgeType == fEdgeType);
147 } 147 }
148 148
149 ////////////////////////////////////////////////////////////////////////////// 149 //////////////////////////////////////////////////////////////////////////////
150 150
151 GR_DEFINE_EFFECT_TEST(GrConicEffect); 151 GR_DEFINE_EFFECT_TEST(GrConicEffect);
152 152
153 GrEffect* GrConicEffect::TestCreate(SkRandom* random, 153 GrEffect* GrConicEffect::TestCreate(SkRandom* random,
154 GrContext*, 154 GrContext*,
155 const GrDrawTargetCaps& caps, 155 const GrDrawTargetCaps& caps,
156 GrTexture*[]) { 156 GrTexture*[]) {
157 GrEffect* effect; 157 GrEffect* effect;
158 do { 158 do {
159 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( 159 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(
160 random->nextULessThan(kGrEff ectEdgeTypeCnt)); 160 random->nextULessThan(kGrEff ectEdgeTypeCnt));
161 effect = GrConicEffect::Create(edgeType, caps); 161 effect = GrConicEffect::Create(edgeType, caps);
162 } while (NULL == effect); 162 } while (NULL == effect);
163 return effect; 163 return effect;
164 } 164 }
165 165
166 ////////////////////////////////////////////////////////////////////////////// 166 //////////////////////////////////////////////////////////////////////////////
167 // Quad 167 // Quad
168 ////////////////////////////////////////////////////////////////////////////// 168 //////////////////////////////////////////////////////////////////////////////
169 169
170 class GrGLQuadEffect : public GrGLGeometryProcessor { 170 class GrGLQuadEffect : public GrGLGeometryProcessor {
171 public: 171 public:
172 GrGLQuadEffect(const GrBackendEffectFactory&, const GrDrawEffect&); 172 GrGLQuadEffect(const GrBackendEffectFactory&, const GrEffect&);
173 173
174 virtual void emitCode(GrGLFullProgramBuilder* builder, 174 virtual void emitCode(GrGLFullProgramBuilder* builder,
175 const GrDrawEffect& drawEffect, 175 const GrEffect& effect,
176 const GrEffectKey& key, 176 const GrEffectKey& key,
177 const char* outputColor, 177 const char* outputColor,
178 const char* inputColor, 178 const char* inputColor,
179 const TransformedCoordsArray&, 179 const TransformedCoordsArray&,
180 const TextureSamplerArray&) SK_OVERRIDE; 180 const TextureSamplerArray&) SK_OVERRIDE;
181 181
182 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB uilder*); 182 static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuild er*);
183 183
184 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_ OVERRIDE {} 184 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER RIDE {}
185 185
186 private: 186 private:
187 GrEffectEdgeType fEdgeType; 187 GrEffectEdgeType fEdgeType;
188 188
189 typedef GrGLGeometryProcessor INHERITED; 189 typedef GrGLGeometryProcessor INHERITED;
190 }; 190 };
191 191
192 GrGLQuadEffect::GrGLQuadEffect(const GrBackendEffectFactory& factory, 192 GrGLQuadEffect::GrGLQuadEffect(const GrBackendEffectFactory& factory,
193 const GrDrawEffect& drawEffect) 193 const GrEffect& effect)
194 : INHERITED (factory) { 194 : INHERITED (factory) {
195 const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>(); 195 const GrQuadEffect& ce = effect.cast<GrQuadEffect>();
196 fEdgeType = ce.getEdgeType(); 196 fEdgeType = ce.getEdgeType();
197 } 197 }
198 198
199 void GrGLQuadEffect::emitCode(GrGLFullProgramBuilder* builder, 199 void GrGLQuadEffect::emitCode(GrGLFullProgramBuilder* builder,
200 const GrDrawEffect& drawEffect, 200 const GrEffect& effect,
201 const GrEffectKey& key, 201 const GrEffectKey& key,
202 const char* outputColor, 202 const char* outputColor,
203 const char* inputColor, 203 const char* inputColor,
204 const TransformedCoordsArray&, 204 const TransformedCoordsArray&,
205 const TextureSamplerArray& samplers) { 205 const TextureSamplerArray& samplers) {
206 const char *vsName, *fsName; 206 const char *vsName, *fsName;
207 builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName); 207 builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName);
208 208
209 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); 209 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
210 const GrShaderVar& inHairQuadEdge = drawEffect.castEffect<GrQuadEffect>().in HairQuadEdge(); 210 const GrShaderVar& inHairQuadEdge = effect.cast<GrQuadEffect>().inHairQuadEd ge();
211 vsBuilder->codeAppendf("%s = %s;", vsName, inHairQuadEdge.c_str()); 211 vsBuilder->codeAppendf("%s = %s;", vsName, inHairQuadEdge.c_str());
212 212
213 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); 213 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
214 fsBuilder->codeAppendf("float edgeAlpha;"); 214 fsBuilder->codeAppendf("float edgeAlpha;");
215 215
216 switch (fEdgeType) { 216 switch (fEdgeType) {
217 case kHairlineAA_GrEffectEdgeType: { 217 case kHairlineAA_GrEffectEdgeType: {
218 SkAssertResult(fsBuilder->enableFeature( 218 SkAssertResult(fsBuilder->enableFeature(
219 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature) ); 219 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature) );
220 fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", fsName); 220 fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", fsName);
(...skipping 29 matching lines...) Expand all
250 break; 250 break;
251 } 251 }
252 default: 252 default:
253 SkFAIL("Shouldn't get here"); 253 SkFAIL("Shouldn't get here");
254 } 254 }
255 255
256 fsBuilder->codeAppendf("%s = %s;", outputColor, 256 fsBuilder->codeAppendf("%s = %s;", outputColor,
257 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")). c_str()); 257 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")). c_str());
258 } 258 }
259 259
260 void GrGLQuadEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, 260 void GrGLQuadEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
261 GrEffectKeyBuilder* b) { 261 GrEffectKeyBuilder* b) {
262 const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>(); 262 const GrQuadEffect& ce = effect.cast<GrQuadEffect>();
263 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; 263 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
264 b->add32(key); 264 b->add32(key);
265 } 265 }
266 266
267 ////////////////////////////////////////////////////////////////////////////// 267 //////////////////////////////////////////////////////////////////////////////
268 268
269 GrQuadEffect::~GrQuadEffect() {} 269 GrQuadEffect::~GrQuadEffect() {}
270 270
271 const GrBackendEffectFactory& GrQuadEffect::getFactory() const { 271 const GrBackendEffectFactory& GrQuadEffect::getFactory() const {
272 return GrTBackendEffectFactory<GrQuadEffect>::getInstance(); 272 return GrTBackendEffectFactory<GrQuadEffect>::getInstance();
273 } 273 }
274 274
275 GrQuadEffect::GrQuadEffect(GrEffectEdgeType edgeType) 275 GrQuadEffect::GrQuadEffect(GrEffectEdgeType edgeType)
276 : fEdgeType(edgeType) 276 : fEdgeType(edgeType)
277 , fInHairQuadEdge(this->addVertexAttrib(GrShaderVar("inCubicCoeffs", 277 , fInHairQuadEdge(this->addVertexAttrib(GrShaderVar("inCubicCoeffs",
278 kVec4f_GrSLType, 278 kVec4f_GrSLType,
279 GrShaderVar::kAttribute_ TypeModifier))) { 279 GrShaderVar::kAttribute_ TypeModifier))) {
280 } 280 }
281 281
282 bool GrQuadEffect::onIsEqual(const GrEffect& other) const { 282 bool GrQuadEffect::onIsEqual(const GrEffect& other) const {
283 const GrQuadEffect& ce = CastEffect<GrQuadEffect>(other); 283 const GrQuadEffect& ce = other.cast<GrQuadEffect>();
284 return (ce.fEdgeType == fEdgeType); 284 return (ce.fEdgeType == fEdgeType);
285 } 285 }
286 286
287 ////////////////////////////////////////////////////////////////////////////// 287 //////////////////////////////////////////////////////////////////////////////
288 288
289 GR_DEFINE_EFFECT_TEST(GrQuadEffect); 289 GR_DEFINE_EFFECT_TEST(GrQuadEffect);
290 290
291 GrEffect* GrQuadEffect::TestCreate(SkRandom* random, 291 GrEffect* GrQuadEffect::TestCreate(SkRandom* random,
292 GrContext*, 292 GrContext*,
293 const GrDrawTargetCaps& caps, 293 const GrDrawTargetCaps& caps,
294 GrTexture*[]) { 294 GrTexture*[]) {
295 GrEffect* effect; 295 GrEffect* effect;
296 do { 296 do {
297 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( 297 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(
298 random->nextULessThan(kGrEff ectEdgeTypeCnt)); 298 random->nextULessThan(kGrEff ectEdgeTypeCnt));
299 effect = GrQuadEffect::Create(edgeType, caps); 299 effect = GrQuadEffect::Create(edgeType, caps);
300 } while (NULL == effect); 300 } while (NULL == effect);
301 return effect; 301 return effect;
302 } 302 }
303 303
304 ////////////////////////////////////////////////////////////////////////////// 304 //////////////////////////////////////////////////////////////////////////////
305 // Cubic 305 // Cubic
306 ////////////////////////////////////////////////////////////////////////////// 306 //////////////////////////////////////////////////////////////////////////////
307 307
308 class GrGLCubicEffect : public GrGLGeometryProcessor { 308 class GrGLCubicEffect : public GrGLGeometryProcessor {
309 public: 309 public:
310 GrGLCubicEffect(const GrBackendEffectFactory&, const GrDrawEffect&); 310 GrGLCubicEffect(const GrBackendEffectFactory&, const GrEffect&);
311 311
312 virtual void emitCode(GrGLFullProgramBuilder* builder, 312 virtual void emitCode(GrGLFullProgramBuilder* builder,
313 const GrDrawEffect& drawEffect, 313 const GrEffect& effect,
314 const GrEffectKey& key, 314 const GrEffectKey& key,
315 const char* outputColor, 315 const char* outputColor,
316 const char* inputColor, 316 const char* inputColor,
317 const TransformedCoordsArray&, 317 const TransformedCoordsArray&,
318 const TextureSamplerArray&) SK_OVERRIDE; 318 const TextureSamplerArray&) SK_OVERRIDE;
319 319
320 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB uilder*); 320 static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuild er*);
321 321
322 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_ OVERRIDE {} 322 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER RIDE {}
323 323
324 private: 324 private:
325 GrEffectEdgeType fEdgeType; 325 GrEffectEdgeType fEdgeType;
326 326
327 typedef GrGLGeometryProcessor INHERITED; 327 typedef GrGLGeometryProcessor INHERITED;
328 }; 328 };
329 329
330 GrGLCubicEffect::GrGLCubicEffect(const GrBackendEffectFactory& factory, 330 GrGLCubicEffect::GrGLCubicEffect(const GrBackendEffectFactory& factory,
331 const GrDrawEffect& drawEffect) 331 const GrEffect& effect)
332 : INHERITED (factory) { 332 : INHERITED (factory) {
333 const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>(); 333 const GrCubicEffect& ce = effect.cast<GrCubicEffect>();
334 fEdgeType = ce.getEdgeType(); 334 fEdgeType = ce.getEdgeType();
335 } 335 }
336 336
337 void GrGLCubicEffect::emitCode(GrGLFullProgramBuilder* builder, 337 void GrGLCubicEffect::emitCode(GrGLFullProgramBuilder* builder,
338 const GrDrawEffect& drawEffect, 338 const GrEffect& effect,
339 const GrEffectKey& key, 339 const GrEffectKey& key,
340 const char* outputColor, 340 const char* outputColor,
341 const char* inputColor, 341 const char* inputColor,
342 const TransformedCoordsArray&, 342 const TransformedCoordsArray&,
343 const TextureSamplerArray& samplers) { 343 const TextureSamplerArray& samplers) {
344 const char *vsName, *fsName; 344 const char *vsName, *fsName;
345 345
346 builder->addVarying(kVec4f_GrSLType, "CubicCoeffs", 346 builder->addVarying(kVec4f_GrSLType, "CubicCoeffs",
347 &vsName, &fsName, GrGLShaderVar::kHigh_Precision); 347 &vsName, &fsName, GrGLShaderVar::kHigh_Precision);
348 348
349 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder(); 349 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
350 const GrShaderVar& inCubicCoeffs = drawEffect.castEffect<GrCubicEffect>().in CubicCoeffs(); 350 const GrShaderVar& inCubicCoeffs = effect.cast<GrCubicEffect>().inCubicCoeff s();
351 vsBuilder->codeAppendf("%s = %s;", vsName, inCubicCoeffs.c_str()); 351 vsBuilder->codeAppendf("%s = %s;", vsName, inCubicCoeffs.c_str());
352 352
353 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); 353 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
354 354
355 GrGLShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, GrGLShaderVar::kHig h_Precision); 355 GrGLShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, GrGLShaderVar::kHig h_Precision);
356 GrGLShaderVar dklmdx("dklmdx", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Prec ision); 356 GrGLShaderVar dklmdx("dklmdx", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Prec ision);
357 GrGLShaderVar dklmdy("dklmdy", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Prec ision); 357 GrGLShaderVar dklmdy("dklmdy", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Prec ision);
358 GrGLShaderVar dfdx("dfdx", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio n); 358 GrGLShaderVar dfdx("dfdx", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio n);
359 GrGLShaderVar dfdy("dfdy", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio n); 359 GrGLShaderVar dfdy("dfdy", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio n);
360 GrGLShaderVar gF("gF", kVec2f_GrSLType, 0, GrGLShaderVar::kHigh_Precision); 360 GrGLShaderVar gF("gF", kVec2f_GrSLType, 0, GrGLShaderVar::kHigh_Precision);
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after
430 break; 430 break;
431 } 431 }
432 default: 432 default:
433 SkFAIL("Shouldn't get here"); 433 SkFAIL("Shouldn't get here");
434 } 434 }
435 435
436 fsBuilder->codeAppendf("%s = %s;", outputColor, 436 fsBuilder->codeAppendf("%s = %s;", outputColor,
437 (GrGLSLExpr4(inputColor) * GrGLSLExpr1(edgeAlpha.c_st r())).c_str()); 437 (GrGLSLExpr4(inputColor) * GrGLSLExpr1(edgeAlpha.c_st r())).c_str());
438 } 438 }
439 439
440 void GrGLCubicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, 440 void GrGLCubicEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
441 GrEffectKeyBuilder* b) { 441 GrEffectKeyBuilder* b) {
442 const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>(); 442 const GrCubicEffect& ce = effect.cast<GrCubicEffect>();
443 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2; 443 uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
444 b->add32(key); 444 b->add32(key);
445 } 445 }
446 446
447 ////////////////////////////////////////////////////////////////////////////// 447 //////////////////////////////////////////////////////////////////////////////
448 448
449 GrCubicEffect::~GrCubicEffect() {} 449 GrCubicEffect::~GrCubicEffect() {}
450 450
451 const GrBackendEffectFactory& GrCubicEffect::getFactory() const { 451 const GrBackendEffectFactory& GrCubicEffect::getFactory() const {
452 return GrTBackendEffectFactory<GrCubicEffect>::getInstance(); 452 return GrTBackendEffectFactory<GrCubicEffect>::getInstance();
453 } 453 }
454 454
455 GrCubicEffect::GrCubicEffect(GrEffectEdgeType edgeType) 455 GrCubicEffect::GrCubicEffect(GrEffectEdgeType edgeType)
456 : fEdgeType(edgeType) 456 : fEdgeType(edgeType)
457 , fInCubicCoeffs(this->addVertexAttrib(GrShaderVar("inCubicCoeffs", 457 , fInCubicCoeffs(this->addVertexAttrib(GrShaderVar("inCubicCoeffs",
458 kVec4f_GrSLType, 458 kVec4f_GrSLType,
459 GrShaderVar::kAttribute_T ypeModifier))) { 459 GrShaderVar::kAttribute_T ypeModifier))) {
460 } 460 }
461 461
462 bool GrCubicEffect::onIsEqual(const GrEffect& other) const { 462 bool GrCubicEffect::onIsEqual(const GrEffect& other) const {
463 const GrCubicEffect& ce = CastEffect<GrCubicEffect>(other); 463 const GrCubicEffect& ce = other.cast<GrCubicEffect>();
464 return (ce.fEdgeType == fEdgeType); 464 return (ce.fEdgeType == fEdgeType);
465 } 465 }
466 466
467 ////////////////////////////////////////////////////////////////////////////// 467 //////////////////////////////////////////////////////////////////////////////
468 468
469 GR_DEFINE_EFFECT_TEST(GrCubicEffect); 469 GR_DEFINE_EFFECT_TEST(GrCubicEffect);
470 470
471 GrEffect* GrCubicEffect::TestCreate(SkRandom* random, 471 GrEffect* GrCubicEffect::TestCreate(SkRandom* random,
472 GrContext*, 472 GrContext*,
473 const GrDrawTargetCaps& caps, 473 const GrDrawTargetCaps& caps,
474 GrTexture*[]) { 474 GrTexture*[]) {
475 GrEffect* effect; 475 GrEffect* effect;
476 do { 476 do {
477 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( 477 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(
478 random->nextULessThan(kGrEff ectEdgeTypeCnt)); 478 random->nextULessThan(kGrEff ectEdgeTypeCnt));
479 effect = GrCubicEffect::Create(edgeType, caps); 479 effect = GrCubicEffect::Create(edgeType, caps);
480 } while (NULL == effect); 480 } while (NULL == effect);
481 return effect; 481 return effect;
482 } 482 }
483 483
OLDNEW
« no previous file with comments | « src/gpu/GrOvalRenderer.cpp ('k') | src/gpu/effects/GrBicubicEffect.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698