OLD | NEW |
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 "GrBezierEffect.h" | 8 #include "GrBezierEffect.h" |
9 | 9 |
10 #include "gl/builders/GrGLFullProgramBuilder.h" | 10 #include "gl/builders/GrGLFullProgramBuilder.h" |
11 #include "gl/GrGLEffect.h" | 11 #include "gl/GrGLProcessor.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 "GrTBackendProcessorFactory.h" |
15 | 15 |
16 class GrGLConicEffect : public GrGLGeometryProcessor { | 16 class GrGLConicEffect : public GrGLGeometryProcessor { |
17 public: | 17 public: |
18 GrGLConicEffect(const GrBackendEffectFactory&, const GrEffect&); | 18 GrGLConicEffect(const GrBackendProcessorFactory&, const GrProcessor&); |
19 | 19 |
20 virtual void emitCode(GrGLFullProgramBuilder* builder, | 20 virtual void emitCode(GrGLFullProgramBuilder* builder, |
21 const GrEffect& effect, | 21 const GrGeometryProcessor& geometryProcessor, |
22 const GrEffectKey& key, | 22 const GrProcessorKey& 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 GrEffect&, const GrGLCaps&, GrEffectKeyBuild
er*); | 28 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); |
29 | 29 |
30 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE {} | 30 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE {} |
31 | 31 |
32 private: | 32 private: |
33 GrEffectEdgeType fEdgeType; | 33 GrProcessorEdgeType 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 GrBackendProcessorFactory& factory, |
39 const GrEffect& effect) | 39 const GrProcessor& effect) |
40 : INHERITED (factory) { | 40 : INHERITED (factory) { |
41 const GrConicEffect& ce = effect.cast<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 GrEffect& effect, | 46 const GrGeometryProcessor& geometryProcessor, |
47 const GrEffectKey& key, | 47 const GrProcessorKey& 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 = effect.cast<GrConicEffect>().inConicCoeff
s(); | 57 const GrShaderVar& inConicCoeffs = geometryProcessor.cast<GrConicEffect>().i
nConicCoeffs(); |
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 GrGLBaseFragmentShaderBuilder* 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_GrProcessorEdgeType: { |
66 SkAssertResult(fsBuilder->enableFeature( | 66 SkAssertResult(fsBuilder->enableFeature( |
67 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 67 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
68 fsBuilder->codeAppendf("vec3 dklmdx = dFdx(%s.xyz);", fsName); | 68 fsBuilder->codeAppendf("vec3 dklmdx = dFdx(%s.xyz);", fsName); |
69 fsBuilder->codeAppendf("vec3 dklmdy = dFdy(%s.xyz);", fsName); | 69 fsBuilder->codeAppendf("vec3 dklmdy = dFdy(%s.xyz);", fsName); |
70 fsBuilder->codeAppendf("float dfdx =" | 70 fsBuilder->codeAppendf("float dfdx =" |
71 "2.0 * %s.x * dklmdx.x - %s.y * dklmdx.z - %s
.z * dklmdx.y;", | 71 "2.0 * %s.x * dklmdx.x - %s.y * dklmdx.z - %s
.z * dklmdx.y;", |
72 fsName, fsName, fsName); | 72 fsName, fsName, fsName); |
73 fsBuilder->codeAppendf("float dfdy =" | 73 fsBuilder->codeAppendf("float dfdy =" |
74 "2.0 * %s.x * dklmdy.x - %s.y * dklmdy.z - %s
.z * dklmdy.y;", | 74 "2.0 * %s.x * dklmdy.x - %s.y * dklmdy.z - %s
.z * dklmdy.y;", |
75 fsName, fsName, fsName); | 75 fsName, fsName, fsName); |
76 fsBuilder->codeAppend("vec2 gF = vec2(dfdx, dfdy);"); | 76 fsBuilder->codeAppend("vec2 gF = vec2(dfdx, dfdy);"); |
77 fsBuilder->codeAppend("float gFM = sqrt(dot(gF, gF));"); | 77 fsBuilder->codeAppend("float gFM = sqrt(dot(gF, gF));"); |
78 fsBuilder->codeAppendf("float func = %s.x*%s.x - %s.y*%s.z;", fsName
, fsName, | 78 fsBuilder->codeAppendf("float func = %s.x*%s.x - %s.y*%s.z;", fsName
, fsName, |
79 fsName, fsName); | 79 fsName, fsName); |
80 fsBuilder->codeAppend("func = abs(func);"); | 80 fsBuilder->codeAppend("func = abs(func);"); |
81 fsBuilder->codeAppend("edgeAlpha = func / gFM;"); | 81 fsBuilder->codeAppend("edgeAlpha = func / gFM;"); |
82 fsBuilder->codeAppend("edgeAlpha = max(1.0 - edgeAlpha, 0.0);"); | 82 fsBuilder->codeAppend("edgeAlpha = max(1.0 - edgeAlpha, 0.0);"); |
83 // Add line below for smooth cubic ramp | 83 // Add line below for smooth cubic ramp |
84 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); | 84 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); |
85 break; | 85 break; |
86 } | 86 } |
87 case kFillAA_GrEffectEdgeType: { | 87 case kFillAA_GrProcessorEdgeType: { |
88 SkAssertResult(fsBuilder->enableFeature( | 88 SkAssertResult(fsBuilder->enableFeature( |
89 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 89 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
90 fsBuilder->codeAppendf("vec3 dklmdx = dFdx(%s.xyz);", fsName); | 90 fsBuilder->codeAppendf("vec3 dklmdx = dFdx(%s.xyz);", fsName); |
91 fsBuilder->codeAppendf("vec3 dklmdy = dFdy(%s.xyz);", fsName); | 91 fsBuilder->codeAppendf("vec3 dklmdy = dFdy(%s.xyz);", fsName); |
92 fsBuilder->codeAppendf("float dfdx =" | 92 fsBuilder->codeAppendf("float dfdx =" |
93 "2.0 * %s.x * dklmdx.x - %s.y * dklmdx.z - %s
.z * dklmdx.y;", | 93 "2.0 * %s.x * dklmdx.x - %s.y * dklmdx.z - %s
.z * dklmdx.y;", |
94 fsName, fsName, fsName); | 94 fsName, fsName, fsName); |
95 fsBuilder->codeAppendf("float dfdy =" | 95 fsBuilder->codeAppendf("float dfdy =" |
96 "2.0 * %s.x * dklmdy.x - %s.y * dklmdy.z - %s
.z * dklmdy.y;", | 96 "2.0 * %s.x * dklmdy.x - %s.y * dklmdy.z - %s
.z * dklmdy.y;", |
97 fsName, fsName, fsName); | 97 fsName, fsName, fsName); |
98 fsBuilder->codeAppend("vec2 gF = vec2(dfdx, dfdy);"); | 98 fsBuilder->codeAppend("vec2 gF = vec2(dfdx, dfdy);"); |
99 fsBuilder->codeAppend("float gFM = sqrt(dot(gF, gF));"); | 99 fsBuilder->codeAppend("float gFM = sqrt(dot(gF, gF));"); |
100 fsBuilder->codeAppendf("float func = %s.x * %s.x - %s.y * %s.z;", fs
Name, fsName, | 100 fsBuilder->codeAppendf("float func = %s.x * %s.x - %s.y * %s.z;", fs
Name, fsName, |
101 fsName, fsName); | 101 fsName, fsName); |
102 fsBuilder->codeAppend("edgeAlpha = func / gFM;"); | 102 fsBuilder->codeAppend("edgeAlpha = func / gFM;"); |
103 fsBuilder->codeAppend("edgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1.0);
"); | 103 fsBuilder->codeAppend("edgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1.0);
"); |
104 // Add line below for smooth cubic ramp | 104 // Add line below for smooth cubic ramp |
105 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); | 105 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); |
106 break; | 106 break; |
107 } | 107 } |
108 case kFillBW_GrEffectEdgeType: { | 108 case kFillBW_GrProcessorEdgeType: { |
109 fsBuilder->codeAppendf("edgeAlpha = %s.x * %s.x - %s.y * %s.z;", fsN
ame, fsName, | 109 fsBuilder->codeAppendf("edgeAlpha = %s.x * %s.x - %s.y * %s.z;", fsN
ame, fsName, |
110 fsName, fsName); | 110 fsName, fsName); |
111 fsBuilder->codeAppend("edgeAlpha = float(edgeAlpha < 0.0);"); | 111 fsBuilder->codeAppend("edgeAlpha = float(edgeAlpha < 0.0);"); |
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 GrEffect& effect, const GrGLCaps&, | 122 void GrGLConicEffect::GenKey(const GrProcessor& processor, const GrGLCaps&, |
123 GrEffectKeyBuilder* b) { | 123 GrProcessorKeyBuilder* b) { |
124 const GrConicEffect& ce = effect.cast<GrConicEffect>(); | 124 const GrConicEffect& ce = processor.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 GrBackendGeometryProcessorFactory& GrConicEffect::getFactory() const { |
134 return GrTBackendEffectFactory<GrConicEffect>::getInstance(); | 134 return GrTBackendGeometryProcessorFactory<GrConicEffect>::getInstance(); |
135 } | 135 } |
136 | 136 |
137 GrConicEffect::GrConicEffect(GrEffectEdgeType edgeType) | 137 GrConicEffect::GrConicEffect(GrProcessorEdgeType 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 GrProcessor& other) const { |
145 const GrConicEffect& ce = other.cast<GrConicEffect>(); | 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_GEOMETRY_PROCESSOR_TEST(GrConicEffect); |
152 | 152 |
153 GrEffect* GrConicEffect::TestCreate(SkRandom* random, | 153 GrGeometryProcessor* GrConicEffect::TestCreate(SkRandom* random, |
154 GrContext*, | 154 GrContext*, |
155 const GrDrawTargetCaps& caps, | 155 const GrDrawTargetCaps& caps, |
156 GrTexture*[]) { | 156 GrTexture*[]) { |
157 GrEffect* effect; | 157 GrGeometryProcessor* gp; |
158 do { | 158 do { |
159 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( | 159 GrProcessorEdgeType edgeType = static_cast<GrProcessorEdgeType>( |
160 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); | 160 random->nextULessThan(kGrPro
cessorEdgeTypeCnt)); |
161 effect = GrConicEffect::Create(edgeType, caps); | 161 gp = GrConicEffect::Create(edgeType, caps); |
162 } while (NULL == effect); | 162 } while (NULL == gp); |
163 return effect; | 163 return gp; |
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 GrEffect&); | 172 GrGLQuadEffect(const GrBackendProcessorFactory&, const GrProcessor&); |
173 | 173 |
174 virtual void emitCode(GrGLFullProgramBuilder* builder, | 174 virtual void emitCode(GrGLFullProgramBuilder* builder, |
175 const GrEffect& effect, | 175 const GrGeometryProcessor& geometryProcessor, |
176 const GrEffectKey& key, | 176 const GrProcessorKey& 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 GrEffect&, const GrGLCaps&, GrEffectKeyBuild
er*); | 182 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); |
183 | 183 |
184 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE {} | 184 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE {} |
185 | 185 |
186 private: | 186 private: |
187 GrEffectEdgeType fEdgeType; | 187 GrProcessorEdgeType 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 GrBackendProcessorFactory& factory, |
193 const GrEffect& effect) | 193 const GrProcessor& effect) |
194 : INHERITED (factory) { | 194 : INHERITED (factory) { |
195 const GrQuadEffect& ce = effect.cast<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 GrEffect& effect, | 200 const GrGeometryProcessor& geometryProcessor, |
201 const GrEffectKey& key, | 201 const GrProcessorKey& 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 = effect.cast<GrQuadEffect>().inHairQuadEd
ge(); | 210 const GrShaderVar& inHairQuadEdge = geometryProcessor.cast<GrQuadEffect>().i
nHairQuadEdge(); |
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 GrGLBaseFragmentShaderBuilder* 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_GrProcessorEdgeType: { |
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); |
221 fsBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", fsName); | 221 fsBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", fsName); |
222 fsBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.
y," | 222 fsBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.
y," |
223 " 2.0 * %s.x * duvdy.x - duvdy.
y);", | 223 " 2.0 * %s.x * duvdy.x - duvdy.
y);", |
224 fsName, fsName); | 224 fsName, fsName); |
225 fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", fsName,
fsName, fsName); | 225 fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", fsName,
fsName, fsName); |
226 fsBuilder->codeAppend("edgeAlpha = sqrt(edgeAlpha * edgeAlpha / dot(
gF, gF));"); | 226 fsBuilder->codeAppend("edgeAlpha = sqrt(edgeAlpha * edgeAlpha / dot(
gF, gF));"); |
227 fsBuilder->codeAppend("edgeAlpha = max(1.0 - edgeAlpha, 0.0);"); | 227 fsBuilder->codeAppend("edgeAlpha = max(1.0 - edgeAlpha, 0.0);"); |
228 // Add line below for smooth cubic ramp | 228 // Add line below for smooth cubic ramp |
229 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); | 229 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); |
230 break; | 230 break; |
231 } | 231 } |
232 case kFillAA_GrEffectEdgeType: { | 232 case kFillAA_GrProcessorEdgeType: { |
233 SkAssertResult(fsBuilder->enableFeature( | 233 SkAssertResult(fsBuilder->enableFeature( |
234 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 234 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
235 fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", fsName); | 235 fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", fsName); |
236 fsBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", fsName); | 236 fsBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", fsName); |
237 fsBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.
y," | 237 fsBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.
y," |
238 " 2.0 * %s.x * duvdy.x - duvdy.
y);", | 238 " 2.0 * %s.x * duvdy.x - duvdy.
y);", |
239 fsName, fsName); | 239 fsName, fsName); |
240 fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", fsName,
fsName, fsName); | 240 fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", fsName,
fsName, fsName); |
241 fsBuilder->codeAppend("edgeAlpha = edgeAlpha / sqrt(dot(gF, gF));"); | 241 fsBuilder->codeAppend("edgeAlpha = edgeAlpha / sqrt(dot(gF, gF));"); |
242 fsBuilder->codeAppend("edgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1.0);
"); | 242 fsBuilder->codeAppend("edgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1.0);
"); |
243 // Add line below for smooth cubic ramp | 243 // Add line below for smooth cubic ramp |
244 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); | 244 // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*e
dgeAlpha);"); |
245 break; | 245 break; |
246 } | 246 } |
247 case kFillBW_GrEffectEdgeType: { | 247 case kFillBW_GrProcessorEdgeType: { |
248 fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", fsName,
fsName, fsName); | 248 fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", fsName,
fsName, fsName); |
249 fsBuilder->codeAppend("edgeAlpha = float(edgeAlpha < 0.0);"); | 249 fsBuilder->codeAppend("edgeAlpha = float(edgeAlpha < 0.0);"); |
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 GrEffect& effect, const GrGLCaps&, | 260 void GrGLQuadEffect::GenKey(const GrProcessor& processor, const GrGLCaps&, |
261 GrEffectKeyBuilder* b) { | 261 GrProcessorKeyBuilder* b) { |
262 const GrQuadEffect& ce = effect.cast<GrQuadEffect>(); | 262 const GrQuadEffect& ce = processor.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 GrBackendGeometryProcessorFactory& GrQuadEffect::getFactory() const { |
272 return GrTBackendEffectFactory<GrQuadEffect>::getInstance(); | 272 return GrTBackendGeometryProcessorFactory<GrQuadEffect>::getInstance(); |
273 } | 273 } |
274 | 274 |
275 GrQuadEffect::GrQuadEffect(GrEffectEdgeType edgeType) | 275 GrQuadEffect::GrQuadEffect(GrProcessorEdgeType 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 GrProcessor& other) const { |
283 const GrQuadEffect& ce = other.cast<GrQuadEffect>(); | 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_GEOMETRY_PROCESSOR_TEST(GrQuadEffect); |
290 | 290 |
291 GrEffect* GrQuadEffect::TestCreate(SkRandom* random, | 291 GrGeometryProcessor* GrQuadEffect::TestCreate(SkRandom* random, |
292 GrContext*, | 292 GrContext*, |
293 const GrDrawTargetCaps& caps, | 293 const GrDrawTargetCaps& caps, |
294 GrTexture*[]) { | 294 GrTexture*[]) { |
295 GrEffect* effect; | 295 GrGeometryProcessor* gp; |
296 do { | 296 do { |
297 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( | 297 GrProcessorEdgeType edgeType = static_cast<GrProcessorEdgeType>( |
298 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); | 298 random->nextULessThan(kGrProcessorEdgeTypeCnt)); |
299 effect = GrQuadEffect::Create(edgeType, caps); | 299 gp = GrQuadEffect::Create(edgeType, caps); |
300 } while (NULL == effect); | 300 } while (NULL == gp); |
301 return effect; | 301 return gp; |
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 GrEffect&); | 310 GrGLCubicEffect(const GrBackendProcessorFactory&, const GrProcessor&); |
311 | 311 |
312 virtual void emitCode(GrGLFullProgramBuilder* builder, | 312 virtual void emitCode(GrGLFullProgramBuilder* builder, |
313 const GrEffect& effect, | 313 const GrGeometryProcessor& geometryProcessor, |
314 const GrEffectKey& key, | 314 const GrProcessorKey& 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 GrEffect&, const GrGLCaps&, GrEffectKeyBuild
er*); | 320 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); |
321 | 321 |
322 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE {} | 322 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE {} |
323 | 323 |
324 private: | 324 private: |
325 GrEffectEdgeType fEdgeType; | 325 GrProcessorEdgeType 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 GrBackendProcessorFactory& factory, |
331 const GrEffect& effect) | 331 const GrProcessor& processor) |
332 : INHERITED (factory) { | 332 : INHERITED (factory) { |
333 const GrCubicEffect& ce = effect.cast<GrCubicEffect>(); | 333 const GrCubicEffect& ce = processor.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 GrEffect& effect, | 338 const GrGeometryProcessor& geometryProcessor, |
339 const GrEffectKey& key, | 339 const GrProcessorKey& 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 = effect.cast<GrCubicEffect>().inCubicCoeff
s(); | 350 const GrShaderVar& inCubicCoeffs = geometryProcessor.cast<GrCubicEffect>().i
nCubicCoeffs(); |
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 GrGLBaseFragmentShaderBuilder* 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); |
361 GrGLShaderVar gFM("gFM", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precision)
; | 361 GrGLShaderVar gFM("gFM", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precision)
; |
362 GrGLShaderVar func("func", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio
n); | 362 GrGLShaderVar func("func", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precisio
n); |
363 | 363 |
364 fsBuilder->declAppend(edgeAlpha); | 364 fsBuilder->declAppend(edgeAlpha); |
365 fsBuilder->declAppend(dklmdx); | 365 fsBuilder->declAppend(dklmdx); |
366 fsBuilder->declAppend(dklmdy); | 366 fsBuilder->declAppend(dklmdy); |
367 fsBuilder->declAppend(dfdx); | 367 fsBuilder->declAppend(dfdx); |
368 fsBuilder->declAppend(dfdy); | 368 fsBuilder->declAppend(dfdy); |
369 fsBuilder->declAppend(gF); | 369 fsBuilder->declAppend(gF); |
370 fsBuilder->declAppend(gFM); | 370 fsBuilder->declAppend(gFM); |
371 fsBuilder->declAppend(func); | 371 fsBuilder->declAppend(func); |
372 | 372 |
373 switch (fEdgeType) { | 373 switch (fEdgeType) { |
374 case kHairlineAA_GrEffectEdgeType: { | 374 case kHairlineAA_GrProcessorEdgeType: { |
375 SkAssertResult(fsBuilder->enableFeature( | 375 SkAssertResult(fsBuilder->enableFeature( |
376 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 376 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
377 fsBuilder->codeAppendf("%s = dFdx(%s.xyz);", dklmdx.c_str(), fsName)
; | 377 fsBuilder->codeAppendf("%s = dFdx(%s.xyz);", dklmdx.c_str(), fsName)
; |
378 fsBuilder->codeAppendf("%s = dFdy(%s.xyz);", dklmdy.c_str(), fsName)
; | 378 fsBuilder->codeAppendf("%s = dFdy(%s.xyz);", dklmdy.c_str(), fsName)
; |
379 fsBuilder->codeAppendf("%s = 3.0 * %s.x * %s.x * %s.x - %s.y * %s.z
- %s.z * %s.y;", | 379 fsBuilder->codeAppendf("%s = 3.0 * %s.x * %s.x * %s.x - %s.y * %s.z
- %s.z * %s.y;", |
380 dfdx.c_str(), fsName, fsName, dklmdx.c_str(),
fsName, | 380 dfdx.c_str(), fsName, fsName, dklmdx.c_str(),
fsName, |
381 dklmdx.c_str(), fsName, dklmdx.c_str()); | 381 dklmdx.c_str(), fsName, dklmdx.c_str()); |
382 fsBuilder->codeAppendf("%s = 3.0 * %s.x * %s.x * %s.x - %s.y * %s.z
- %s.z * %s.y;", | 382 fsBuilder->codeAppendf("%s = 3.0 * %s.x * %s.x * %s.x - %s.y * %s.z
- %s.z * %s.y;", |
383 dfdy.c_str(), fsName, fsName, dklmdy.c_str(),
fsName, | 383 dfdy.c_str(), fsName, fsName, dklmdy.c_str(),
fsName, |
384 dklmdy.c_str(), fsName, dklmdy.c_str()); | 384 dklmdy.c_str(), fsName, dklmdy.c_str()); |
385 fsBuilder->codeAppendf("%s = vec2(%s, %s);", gF.c_str(), dfdx.c_str(
), dfdy.c_str()); | 385 fsBuilder->codeAppendf("%s = vec2(%s, %s);", gF.c_str(), dfdx.c_str(
), dfdy.c_str()); |
386 fsBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", gFM.c_str(), gF.c_
str(), gF.c_str()); | 386 fsBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", gFM.c_str(), gF.c_
str(), gF.c_str()); |
387 fsBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;", | 387 fsBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;", |
388 func.c_str(), fsName, fsName, fsName, fsName,
fsName); | 388 func.c_str(), fsName, fsName, fsName, fsName,
fsName); |
389 fsBuilder->codeAppendf("%s = abs(%s);", func.c_str(), func.c_str()); | 389 fsBuilder->codeAppendf("%s = abs(%s);", func.c_str(), func.c_str()); |
390 fsBuilder->codeAppendf("%s = %s / %s;", | 390 fsBuilder->codeAppendf("%s = %s / %s;", |
391 edgeAlpha.c_str(), func.c_str(), gFM.c_str())
; | 391 edgeAlpha.c_str(), func.c_str(), gFM.c_str())
; |
392 fsBuilder->codeAppendf("%s = max(1.0 - %s, 0.0);", | 392 fsBuilder->codeAppendf("%s = max(1.0 - %s, 0.0);", |
393 edgeAlpha.c_str(), edgeAlpha.c_str()); | 393 edgeAlpha.c_str(), edgeAlpha.c_str()); |
394 // Add line below for smooth cubic ramp | 394 // Add line below for smooth cubic ramp |
395 // fsBuilder->codeAppendf("%s = %s * %s * (3.0 - 2.0 * %s);", | 395 // fsBuilder->codeAppendf("%s = %s * %s * (3.0 - 2.0 * %s);", |
396 // edgeAlpha.c_str(), edgeAlpha.c_str(), edge
Alpha.c_str(), | 396 // edgeAlpha.c_str(), edgeAlpha.c_str(), edge
Alpha.c_str(), |
397 // edgeAlpha.c_str()); | 397 // edgeAlpha.c_str()); |
398 break; | 398 break; |
399 } | 399 } |
400 case kFillAA_GrEffectEdgeType: { | 400 case kFillAA_GrProcessorEdgeType: { |
401 SkAssertResult(fsBuilder->enableFeature( | 401 SkAssertResult(fsBuilder->enableFeature( |
402 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); | 402 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
403 fsBuilder->codeAppendf("%s = dFdx(%s.xyz);", dklmdx.c_str(), fsName)
; | 403 fsBuilder->codeAppendf("%s = dFdx(%s.xyz);", dklmdx.c_str(), fsName)
; |
404 fsBuilder->codeAppendf("%s = dFdy(%s.xyz);", dklmdy.c_str(), fsName)
; | 404 fsBuilder->codeAppendf("%s = dFdy(%s.xyz);", dklmdy.c_str(), fsName)
; |
405 fsBuilder->codeAppendf("%s =" | 405 fsBuilder->codeAppendf("%s =" |
406 "3.0 * %s.x * %s.x * %s.x - %s.y * %s.z - %s.
z * %s.y;", | 406 "3.0 * %s.x * %s.x * %s.x - %s.y * %s.z - %s.
z * %s.y;", |
407 dfdx.c_str(), fsName, fsName, dklmdx.c_str(),
fsName, | 407 dfdx.c_str(), fsName, fsName, dklmdx.c_str(),
fsName, |
408 dklmdx.c_str(), fsName, dklmdx.c_str()); | 408 dklmdx.c_str(), fsName, dklmdx.c_str()); |
409 fsBuilder->codeAppendf("%s = 3.0 * %s.x * %s.x * %s.x - %s.y * %s.z
- %s.z * %s.y;", | 409 fsBuilder->codeAppendf("%s = 3.0 * %s.x * %s.x * %s.x - %s.y * %s.z
- %s.z * %s.y;", |
410 dfdy.c_str(), fsName, fsName, dklmdy.c_str(),
fsName, | 410 dfdy.c_str(), fsName, fsName, dklmdy.c_str(),
fsName, |
411 dklmdy.c_str(), fsName, dklmdy.c_str()); | 411 dklmdy.c_str(), fsName, dklmdy.c_str()); |
412 fsBuilder->codeAppendf("%s = vec2(%s, %s);", gF.c_str(), dfdx.c_str(
), dfdy.c_str()); | 412 fsBuilder->codeAppendf("%s = vec2(%s, %s);", gF.c_str(), dfdx.c_str(
), dfdy.c_str()); |
413 fsBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", gFM.c_str(), gF.c_
str(), gF.c_str()); | 413 fsBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", gFM.c_str(), gF.c_
str(), gF.c_str()); |
414 fsBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;", | 414 fsBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;", |
415 func.c_str(), fsName, fsName, fsName, fsName,
fsName); | 415 func.c_str(), fsName, fsName, fsName, fsName,
fsName); |
416 fsBuilder->codeAppendf("%s = %s / %s;", | 416 fsBuilder->codeAppendf("%s = %s / %s;", |
417 edgeAlpha.c_str(), func.c_str(), gFM.c_str())
; | 417 edgeAlpha.c_str(), func.c_str(), gFM.c_str())
; |
418 fsBuilder->codeAppendf("%s = clamp(1.0 - %s, 0.0, 1.0);", | 418 fsBuilder->codeAppendf("%s = clamp(1.0 - %s, 0.0, 1.0);", |
419 edgeAlpha.c_str(), edgeAlpha.c_str()); | 419 edgeAlpha.c_str(), edgeAlpha.c_str()); |
420 // Add line below for smooth cubic ramp | 420 // Add line below for smooth cubic ramp |
421 // fsBuilder->codeAppendf("%s = %s * %s * (3.0 - 2.0 * %s);", | 421 // fsBuilder->codeAppendf("%s = %s * %s * (3.0 - 2.0 * %s);", |
422 // edgeAlpha.c_str(), edgeAlpha.c_str(), edge
Alpha.c_str(), | 422 // edgeAlpha.c_str(), edgeAlpha.c_str(), edge
Alpha.c_str(), |
423 // edgeAlpha.c_str()); | 423 // edgeAlpha.c_str()); |
424 break; | 424 break; |
425 } | 425 } |
426 case kFillBW_GrEffectEdgeType: { | 426 case kFillBW_GrProcessorEdgeType: { |
427 fsBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;", | 427 fsBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;", |
428 edgeAlpha.c_str(), fsName, fsName, fsName, fs
Name, fsName); | 428 edgeAlpha.c_str(), fsName, fsName, fsName, fs
Name, fsName); |
429 fsBuilder->codeAppendf("%s = float(%s < 0.0);", edgeAlpha.c_str(), e
dgeAlpha.c_str()); | 429 fsBuilder->codeAppendf("%s = float(%s < 0.0);", edgeAlpha.c_str(), e
dgeAlpha.c_str()); |
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 GrEffect& effect, const GrGLCaps&, | 440 void GrGLCubicEffect::GenKey(const GrProcessor& processor, const GrGLCaps&, |
441 GrEffectKeyBuilder* b) { | 441 GrProcessorKeyBuilder* b) { |
442 const GrCubicEffect& ce = effect.cast<GrCubicEffect>(); | 442 const GrCubicEffect& ce = processor.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 GrBackendGeometryProcessorFactory& GrCubicEffect::getFactory() const { |
452 return GrTBackendEffectFactory<GrCubicEffect>::getInstance(); | 452 return GrTBackendGeometryProcessorFactory<GrCubicEffect>::getInstance(); |
453 } | 453 } |
454 | 454 |
455 GrCubicEffect::GrCubicEffect(GrEffectEdgeType edgeType) | 455 GrCubicEffect::GrCubicEffect(GrProcessorEdgeType 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 GrProcessor& other) const { |
463 const GrCubicEffect& ce = other.cast<GrCubicEffect>(); | 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_GEOMETRY_PROCESSOR_TEST(GrCubicEffect); |
470 | 470 |
471 GrEffect* GrCubicEffect::TestCreate(SkRandom* random, | 471 GrGeometryProcessor* GrCubicEffect::TestCreate(SkRandom* random, |
472 GrContext*, | 472 GrContext*, |
473 const GrDrawTargetCaps& caps, | 473 const GrDrawTargetCaps& caps, |
474 GrTexture*[]) { | 474 GrTexture*[]) { |
475 GrEffect* effect; | 475 GrGeometryProcessor* gp; |
476 do { | 476 do { |
477 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( | 477 GrProcessorEdgeType edgeType = static_cast<GrProcessorEdgeType>( |
478 random->nextULessThan(kGrEff
ectEdgeTypeCnt)); | 478 random->nextULessThan(kGrPro
cessorEdgeTypeCnt)); |
479 effect = GrCubicEffect::Create(edgeType, caps); | 479 gp = GrCubicEffect::Create(edgeType, caps); |
480 } while (NULL == effect); | 480 } while (NULL == gp); |
481 return effect; | 481 return gp; |
482 } | 482 } |
483 | 483 |
OLD | NEW |