OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2014 Google Inc. | 2 * Copyright 2014 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 "GrConvexPolyEffect.h" | 9 #include "GrConvexPolyEffect.h" |
10 | 10 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
43 GrEffectEdgeType getEdgeType() const { return fEdgeType; } | 43 GrEffectEdgeType getEdgeType() const { return fEdgeType; } |
44 | 44 |
45 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; | 45 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; |
46 | 46 |
47 private: | 47 private: |
48 AARectEffect(GrEffectEdgeType edgeType, const SkRect& rect) : fRect(rect), f
EdgeType(edgeType) { | 48 AARectEffect(GrEffectEdgeType edgeType, const SkRect& rect) : fRect(rect), f
EdgeType(edgeType) { |
49 this->setWillReadFragmentPosition(); | 49 this->setWillReadFragmentPosition(); |
50 } | 50 } |
51 | 51 |
52 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { | 52 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { |
53 const AARectEffect& aare = other.cast<AARectEffect>(); | 53 const AARectEffect& aare = CastEffect<AARectEffect>(other); |
54 return fRect == aare.fRect; | 54 return fRect == aare.fRect; |
55 } | 55 } |
56 | 56 |
57 SkRect fRect; | 57 SkRect fRect; |
58 GrEffectEdgeType fEdgeType; | 58 GrEffectEdgeType fEdgeType; |
59 | 59 |
60 typedef GrEffect INHERITED; | 60 typedef GrEffect INHERITED; |
61 | 61 |
62 GR_DECLARE_EFFECT_TEST; | 62 GR_DECLARE_EFFECT_TEST; |
63 | 63 |
(...skipping 16 matching lines...) Expand all Loading... |
80 | 80 |
81 effect = AARectEffect::Create(edgeType, rect); | 81 effect = AARectEffect::Create(edgeType, rect); |
82 } while (NULL == effect); | 82 } while (NULL == effect); |
83 return effect; | 83 return effect; |
84 } | 84 } |
85 | 85 |
86 ////////////////////////////////////////////////////////////////////////////// | 86 ////////////////////////////////////////////////////////////////////////////// |
87 | 87 |
88 class GLAARectEffect : public GrGLEffect { | 88 class GLAARectEffect : public GrGLEffect { |
89 public: | 89 public: |
90 GLAARectEffect(const GrBackendEffectFactory&, const GrEffect&); | 90 GLAARectEffect(const GrBackendEffectFactory&, const GrDrawEffect&); |
91 | 91 |
92 virtual void emitCode(GrGLProgramBuilder* builder, | 92 virtual void emitCode(GrGLProgramBuilder* builder, |
93 const GrEffect& effect, | 93 const GrDrawEffect& drawEffect, |
94 const GrEffectKey& key, | 94 const GrEffectKey& key, |
95 const char* outputColor, | 95 const char* outputColor, |
96 const char* inputColor, | 96 const char* inputColor, |
97 const TransformedCoordsArray&, | 97 const TransformedCoordsArray&, |
98 const TextureSamplerArray&) SK_OVERRIDE; | 98 const TextureSamplerArray&) SK_OVERRIDE; |
99 | 99 |
100 static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuild
er*); | 100 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); |
101 | 101 |
102 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE; | 102 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; |
103 | 103 |
104 private: | 104 private: |
105 GrGLProgramDataManager::UniformHandle fRectUniform; | 105 GrGLProgramDataManager::UniformHandle fRectUniform; |
106 SkRect fPrevRect; | 106 SkRect fPrevRect; |
107 typedef GrGLEffect INHERITED; | 107 typedef GrGLEffect INHERITED; |
108 }; | 108 }; |
109 | 109 |
110 GLAARectEffect::GLAARectEffect(const GrBackendEffectFactory& factory, | 110 GLAARectEffect::GLAARectEffect(const GrBackendEffectFactory& factory, |
111 const GrEffect& effect) | 111 const GrDrawEffect& drawEffect) |
112 : INHERITED (factory) { | 112 : INHERITED (factory) { |
113 fPrevRect.fLeft = SK_ScalarNaN; | 113 fPrevRect.fLeft = SK_ScalarNaN; |
114 } | 114 } |
115 | 115 |
116 void GLAARectEffect::emitCode(GrGLProgramBuilder* builder, | 116 void GLAARectEffect::emitCode(GrGLProgramBuilder* builder, |
117 const GrEffect& effect, | 117 const GrDrawEffect& drawEffect, |
118 const GrEffectKey& key, | 118 const GrEffectKey& key, |
119 const char* outputColor, | 119 const char* outputColor, |
120 const char* inputColor, | 120 const char* inputColor, |
121 const TransformedCoordsArray&, | 121 const TransformedCoordsArray&, |
122 const TextureSamplerArray& samplers) { | 122 const TextureSamplerArray& samplers) { |
123 const AARectEffect& aare = effect.cast<AARectEffect>(); | 123 const AARectEffect& aare = drawEffect.castEffect<AARectEffect>(); |
124 const char *rectName; | 124 const char *rectName; |
125 // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bot
tom - 0.5), | 125 // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bot
tom - 0.5), |
126 // respectively. | 126 // respectively. |
127 fRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, | 127 fRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, |
128 kVec4f_GrSLType, | 128 kVec4f_GrSLType, |
129 "rect", | 129 "rect", |
130 &rectName); | 130 &rectName); |
131 | 131 |
132 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 132 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
133 const char* fragmentPos = fsBuilder->fragmentPosition(); | 133 const char* fragmentPos = fsBuilder->fragmentPosition(); |
(...skipping 16 matching lines...) Expand all Loading... |
150 fsBuilder->codeAppendf("\t\talpha *= (%s.w - %s.y) > -0.5 ? 1.0 : 0.0;\n
", rectName, fragmentPos); | 150 fsBuilder->codeAppendf("\t\talpha *= (%s.w - %s.y) > -0.5 ? 1.0 : 0.0;\n
", rectName, fragmentPos); |
151 } | 151 } |
152 | 152 |
153 if (GrEffectEdgeTypeIsInverseFill(aare.getEdgeType())) { | 153 if (GrEffectEdgeTypeIsInverseFill(aare.getEdgeType())) { |
154 fsBuilder->codeAppend("\t\talpha = 1.0 - alpha;\n"); | 154 fsBuilder->codeAppend("\t\talpha = 1.0 - alpha;\n"); |
155 } | 155 } |
156 fsBuilder->codeAppendf("\t\t%s = %s;\n", outputColor, | 156 fsBuilder->codeAppendf("\t\t%s = %s;\n", outputColor, |
157 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_st
r()); | 157 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_st
r()); |
158 } | 158 } |
159 | 159 |
160 void GLAARectEffect::setData(const GrGLProgramDataManager& pdman, const GrEffect
& effect) { | 160 void GLAARectEffect::setData(const GrGLProgramDataManager& pdman, const GrDrawEf
fect& drawEffect) { |
161 const AARectEffect& aare = effect.cast<AARectEffect>(); | 161 const AARectEffect& aare = drawEffect.castEffect<AARectEffect>(); |
162 const SkRect& rect = aare.getRect(); | 162 const SkRect& rect = aare.getRect(); |
163 if (rect != fPrevRect) { | 163 if (rect != fPrevRect) { |
164 pdman.set4f(fRectUniform, rect.fLeft + 0.5f, rect.fTop + 0.5f, | 164 pdman.set4f(fRectUniform, rect.fLeft + 0.5f, rect.fTop + 0.5f, |
165 rect.fRight - 0.5f, rect.fBottom - 0.5f); | 165 rect.fRight - 0.5f, rect.fBottom - 0.5f); |
166 fPrevRect = rect; | 166 fPrevRect = rect; |
167 } | 167 } |
168 } | 168 } |
169 | 169 |
170 void GLAARectEffect::GenKey(const GrEffect& effect, const GrGLCaps&, | 170 void GLAARectEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
171 GrEffectKeyBuilder* b) { | 171 GrEffectKeyBuilder* b) { |
172 const AARectEffect& aare = effect.cast<AARectEffect>(); | 172 const AARectEffect& aare = drawEffect.castEffect<AARectEffect>(); |
173 b->add32(aare.getEdgeType()); | 173 b->add32(aare.getEdgeType()); |
174 } | 174 } |
175 | 175 |
176 const GrBackendEffectFactory& AARectEffect::getFactory() const { | 176 const GrBackendEffectFactory& AARectEffect::getFactory() const { |
177 return GrTBackendEffectFactory<AARectEffect>::getInstance(); | 177 return GrTBackendEffectFactory<AARectEffect>::getInstance(); |
178 } | 178 } |
179 | 179 |
180 ////////////////////////////////////////////////////////////////////////////// | 180 ////////////////////////////////////////////////////////////////////////////// |
181 | 181 |
182 class GrGLConvexPolyEffect : public GrGLEffect { | 182 class GrGLConvexPolyEffect : public GrGLEffect { |
183 public: | 183 public: |
184 GrGLConvexPolyEffect(const GrBackendEffectFactory&, const GrEffect&); | 184 GrGLConvexPolyEffect(const GrBackendEffectFactory&, const GrDrawEffect&); |
185 | 185 |
186 virtual void emitCode(GrGLProgramBuilder* builder, | 186 virtual void emitCode(GrGLProgramBuilder* builder, |
187 const GrEffect& effect, | 187 const GrDrawEffect& drawEffect, |
188 const GrEffectKey& key, | 188 const GrEffectKey& key, |
189 const char* outputColor, | 189 const char* outputColor, |
190 const char* inputColor, | 190 const char* inputColor, |
191 const TransformedCoordsArray&, | 191 const TransformedCoordsArray&, |
192 const TextureSamplerArray&) SK_OVERRIDE; | 192 const TextureSamplerArray&) SK_OVERRIDE; |
193 | 193 |
194 static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuild
er*); | 194 static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyB
uilder*); |
195 | 195 |
196 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER
RIDE; | 196 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_
OVERRIDE; |
197 | 197 |
198 private: | 198 private: |
199 GrGLProgramDataManager::UniformHandle fEdgeUniform; | 199 GrGLProgramDataManager::UniformHandle fEdgeUniform; |
200 SkScalar fPrevEdges[3 * GrConvexPolyEffect::kMa
xEdges]; | 200 SkScalar fPrevEdges[3 * GrConvexPolyEffect::kMa
xEdges]; |
201 typedef GrGLEffect INHERITED; | 201 typedef GrGLEffect INHERITED; |
202 }; | 202 }; |
203 | 203 |
204 GrGLConvexPolyEffect::GrGLConvexPolyEffect(const GrBackendEffectFactory& factory
, | 204 GrGLConvexPolyEffect::GrGLConvexPolyEffect(const GrBackendEffectFactory& factory
, |
205 const GrEffect& effect) | 205 const GrDrawEffect& drawEffect) |
206 : INHERITED (factory) { | 206 : INHERITED (factory) { |
207 fPrevEdges[0] = SK_ScalarNaN; | 207 fPrevEdges[0] = SK_ScalarNaN; |
208 } | 208 } |
209 | 209 |
210 void GrGLConvexPolyEffect::emitCode(GrGLProgramBuilder* builder, | 210 void GrGLConvexPolyEffect::emitCode(GrGLProgramBuilder* builder, |
211 const GrEffect& effect, | 211 const GrDrawEffect& drawEffect, |
212 const GrEffectKey& key, | 212 const GrEffectKey& key, |
213 const char* outputColor, | 213 const char* outputColor, |
214 const char* inputColor, | 214 const char* inputColor, |
215 const TransformedCoordsArray&, | 215 const TransformedCoordsArray&, |
216 const TextureSamplerArray& samplers) { | 216 const TextureSamplerArray& samplers) { |
217 const GrConvexPolyEffect& cpe = effect.cast<GrConvexPolyEffect>(); | 217 const GrConvexPolyEffect& cpe = drawEffect.castEffect<GrConvexPolyEffect>(); |
218 | 218 |
219 const char *edgeArrayName; | 219 const char *edgeArrayName; |
220 fEdgeUniform = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibi
lity, | 220 fEdgeUniform = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibi
lity, |
221 kVec3f_GrSLType, | 221 kVec3f_GrSLType, |
222 "edges", | 222 "edges", |
223 cpe.getEdgeCount(), | 223 cpe.getEdgeCount(), |
224 &edgeArrayName); | 224 &edgeArrayName); |
225 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); | 225 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); |
226 fsBuilder->codeAppend("\t\tfloat alpha = 1.0;\n"); | 226 fsBuilder->codeAppend("\t\tfloat alpha = 1.0;\n"); |
227 fsBuilder->codeAppend("\t\tfloat edge;\n"); | 227 fsBuilder->codeAppend("\t\tfloat edge;\n"); |
(...skipping 14 matching lines...) Expand all Loading... |
242 fsBuilder->codeAppend("\t\tif (-1.0 == alpha) {\n\t\t\tdiscard;\n\t\t}\n
"); | 242 fsBuilder->codeAppend("\t\tif (-1.0 == alpha) {\n\t\t\tdiscard;\n\t\t}\n
"); |
243 } | 243 } |
244 | 244 |
245 if (GrEffectEdgeTypeIsInverseFill(cpe.getEdgeType())) { | 245 if (GrEffectEdgeTypeIsInverseFill(cpe.getEdgeType())) { |
246 fsBuilder->codeAppend("\talpha = 1.0 - alpha;\n"); | 246 fsBuilder->codeAppend("\talpha = 1.0 - alpha;\n"); |
247 } | 247 } |
248 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, | 248 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, |
249 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_st
r()); | 249 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_st
r()); |
250 } | 250 } |
251 | 251 |
252 void GrGLConvexPolyEffect::setData(const GrGLProgramDataManager& pdman, const Gr
Effect& effect) { | 252 void GrGLConvexPolyEffect::setData(const GrGLProgramDataManager& pdman, const Gr
DrawEffect& drawEffect) { |
253 const GrConvexPolyEffect& cpe = effect.cast<GrConvexPolyEffect>(); | 253 const GrConvexPolyEffect& cpe = drawEffect.castEffect<GrConvexPolyEffect>(); |
254 size_t byteSize = 3 * cpe.getEdgeCount() * sizeof(SkScalar); | 254 size_t byteSize = 3 * cpe.getEdgeCount() * sizeof(SkScalar); |
255 if (0 != memcmp(fPrevEdges, cpe.getEdges(), byteSize)) { | 255 if (0 != memcmp(fPrevEdges, cpe.getEdges(), byteSize)) { |
256 pdman.set3fv(fEdgeUniform, cpe.getEdgeCount(), cpe.getEdges()); | 256 pdman.set3fv(fEdgeUniform, cpe.getEdgeCount(), cpe.getEdges()); |
257 memcpy(fPrevEdges, cpe.getEdges(), byteSize); | 257 memcpy(fPrevEdges, cpe.getEdges(), byteSize); |
258 } | 258 } |
259 } | 259 } |
260 | 260 |
261 void GrGLConvexPolyEffect::GenKey(const GrEffect& effect, const GrGLCaps&, | 261 void GrGLConvexPolyEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps
&, |
262 GrEffectKeyBuilder* b) { | 262 GrEffectKeyBuilder* b) { |
263 const GrConvexPolyEffect& cpe = effect.cast<GrConvexPolyEffect>(); | 263 const GrConvexPolyEffect& cpe = drawEffect.castEffect<GrConvexPolyEffect>(); |
264 GR_STATIC_ASSERT(kGrEffectEdgeTypeCnt <= 8); | 264 GR_STATIC_ASSERT(kGrEffectEdgeTypeCnt <= 8); |
265 uint32_t key = (cpe.getEdgeCount() << 3) | cpe.getEdgeType(); | 265 uint32_t key = (cpe.getEdgeCount() << 3) | cpe.getEdgeType(); |
266 b->add32(key); | 266 b->add32(key); |
267 } | 267 } |
268 | 268 |
269 ////////////////////////////////////////////////////////////////////////////// | 269 ////////////////////////////////////////////////////////////////////////////// |
270 | 270 |
271 GrEffect* GrConvexPolyEffect::Create(GrEffectEdgeType type, const SkPath& path, | 271 GrEffect* GrConvexPolyEffect::Create(GrEffectEdgeType type, const SkPath& path, |
272 const SkVector* offset) { | 272 const SkVector* offset) { |
273 if (kHairlineAA_GrEffectEdgeType == type) { | 273 if (kHairlineAA_GrEffectEdgeType == type) { |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
344 memcpy(fEdges, edges, 3 * n * sizeof(SkScalar)); | 344 memcpy(fEdges, edges, 3 * n * sizeof(SkScalar)); |
345 // Outset the edges by 0.5 so that a pixel with center on an edge is 50% cov
ered in the AA case | 345 // Outset the edges by 0.5 so that a pixel with center on an edge is 50% cov
ered in the AA case |
346 // and 100% covered in the non-AA case. | 346 // and 100% covered in the non-AA case. |
347 for (int i = 0; i < n; ++i) { | 347 for (int i = 0; i < n; ++i) { |
348 fEdges[3 * i + 2] += SK_ScalarHalf; | 348 fEdges[3 * i + 2] += SK_ScalarHalf; |
349 } | 349 } |
350 this->setWillReadFragmentPosition(); | 350 this->setWillReadFragmentPosition(); |
351 } | 351 } |
352 | 352 |
353 bool GrConvexPolyEffect::onIsEqual(const GrEffect& other) const { | 353 bool GrConvexPolyEffect::onIsEqual(const GrEffect& other) const { |
354 const GrConvexPolyEffect& cpe = other.cast<GrConvexPolyEffect>(); | 354 const GrConvexPolyEffect& cpe = CastEffect<GrConvexPolyEffect>(other); |
355 // ignore the fact that 0 == -0 and just use memcmp. | 355 // ignore the fact that 0 == -0 and just use memcmp. |
356 return (cpe.fEdgeType == fEdgeType && cpe.fEdgeCount == fEdgeCount && | 356 return (cpe.fEdgeType == fEdgeType && cpe.fEdgeCount == fEdgeCount && |
357 0 == memcmp(cpe.fEdges, fEdges, 3 * fEdgeCount * sizeof(SkScalar))); | 357 0 == memcmp(cpe.fEdges, fEdges, 3 * fEdgeCount * sizeof(SkScalar))); |
358 } | 358 } |
359 | 359 |
360 ////////////////////////////////////////////////////////////////////////////// | 360 ////////////////////////////////////////////////////////////////////////////// |
361 | 361 |
362 GR_DEFINE_EFFECT_TEST(GrConvexPolyEffect); | 362 GR_DEFINE_EFFECT_TEST(GrConvexPolyEffect); |
363 | 363 |
364 GrEffect* GrConvexPolyEffect::TestCreate(SkRandom* random, | 364 GrEffect* GrConvexPolyEffect::TestCreate(SkRandom* random, |
365 GrContext*, | 365 GrContext*, |
366 const GrDrawTargetCaps& caps, | 366 const GrDrawTargetCaps& caps, |
367 GrTexture*[]) { | 367 GrTexture*[]) { |
368 int count = random->nextULessThan(kMaxEdges) + 1; | 368 int count = random->nextULessThan(kMaxEdges) + 1; |
369 SkScalar edges[kMaxEdges * 3]; | 369 SkScalar edges[kMaxEdges * 3]; |
370 for (int i = 0; i < 3 * count; ++i) { | 370 for (int i = 0; i < 3 * count; ++i) { |
371 edges[i] = random->nextSScalar1(); | 371 edges[i] = random->nextSScalar1(); |
372 } | 372 } |
373 | 373 |
374 GrEffect* effect; | 374 GrEffect* effect; |
375 do { | 375 do { |
376 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( | 376 GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>( |
377 random->nextULessThan(kGrEffectEdgeTypeC
nt)); | 377 random->nextULessThan(kGrEffectEdgeTypeC
nt)); |
378 effect = GrConvexPolyEffect::Create(edgeType, count, edges); | 378 effect = GrConvexPolyEffect::Create(edgeType, count, edges); |
379 } while (NULL == effect); | 379 } while (NULL == effect); |
380 return effect; | 380 return effect; |
381 } | 381 } |
OLD | NEW |