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 "gl/builders/GrGLProgramBuilder.h" | 8 #include "gl/builders/GrGLProgramBuilder.h" |
9 #include "GrOvalRenderer.h" | 9 #include "GrOvalRenderer.h" |
10 | 10 |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
87 } | 87 } |
88 | 88 |
89 virtual ~CircleEdgeEffect() {} | 89 virtual ~CircleEdgeEffect() {} |
90 | 90 |
91 static const char* Name() { return "CircleEdge"; } | 91 static const char* Name() { return "CircleEdge"; } |
92 | 92 |
93 inline bool isStroked() const { return fStroke; } | 93 inline bool isStroked() const { return fStroke; } |
94 | 94 |
95 class GLEffect : public GrGLGeometryProcessor { | 95 class GLEffect : public GrGLGeometryProcessor { |
96 public: | 96 public: |
97 GLEffect(const GrBackendEffectFactory& factory, const GrEffect&) | 97 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) |
98 : INHERITED (factory) {} | 98 : INHERITED (factory) {} |
99 | 99 |
100 virtual void emitCode(GrGLFullProgramBuilder* builder, | 100 virtual void emitCode(GrGLFullProgramBuilder* builder, |
101 const GrEffect& effect, | 101 const GrDrawEffect& drawEffect, |
102 const GrEffectKey& key, | 102 const GrEffectKey& key, |
103 const char* outputColor, | 103 const char* outputColor, |
104 const char* inputColor, | 104 const char* inputColor, |
105 const TransformedCoordsArray&, | 105 const TransformedCoordsArray&, |
106 const TextureSamplerArray& samplers) SK_OVERRIDE { | 106 const TextureSamplerArray& samplers) SK_OVERRIDE { |
107 const CircleEdgeEffect& circleEffect = effect.cast<CircleEdgeEffect>
(); | 107 const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleE
dgeEffect>(); |
108 const char *vsName, *fsName; | 108 const char *vsName, *fsName; |
109 builder->addVarying(kVec4f_GrSLType, "CircleEdge", &vsName, &fsName)
; | 109 builder->addVarying(kVec4f_GrSLType, "CircleEdge", &vsName, &fsName)
; |
110 | 110 |
111 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder
();; | 111 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder
();; |
112 vsBuilder->codeAppendf("\t%s = %s;\n", vsName, circleEffect.inCircle
Edge().c_str()); | 112 vsBuilder->codeAppendf("\t%s = %s;\n", vsName, circleEffect.inCircle
Edge().c_str()); |
113 | 113 |
114 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBui
lder(); | 114 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBui
lder(); |
115 fsBuilder->codeAppendf("\tfloat d = length(%s.xy);\n", fsName); | 115 fsBuilder->codeAppendf("\tfloat d = length(%s.xy);\n", fsName); |
116 fsBuilder->codeAppendf("\tfloat edgeAlpha = clamp(%s.z - d, 0.0, 1.0
);\n", fsName); | 116 fsBuilder->codeAppendf("\tfloat edgeAlpha = clamp(%s.z - d, 0.0, 1.0
);\n", fsName); |
117 if (circleEffect.isStroked()) { | 117 if (circleEffect.isStroked()) { |
118 fsBuilder->codeAppendf("\tfloat innerAlpha = clamp(d - %s.w, 0.0
, 1.0);\n", fsName); | 118 fsBuilder->codeAppendf("\tfloat innerAlpha = clamp(d - %s.w, 0.0
, 1.0);\n", fsName); |
119 fsBuilder->codeAppend("\tedgeAlpha *= innerAlpha;\n"); | 119 fsBuilder->codeAppend("\tedgeAlpha *= innerAlpha;\n"); |
120 } | 120 } |
121 | 121 |
122 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, | 122 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, |
123 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); | 123 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); |
124 } | 124 } |
125 | 125 |
126 static void GenKey(const GrEffect& effect, const GrGLCaps&, | 126 static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
127 GrEffectKeyBuilder* b) { | 127 GrEffectKeyBuilder* b) { |
128 const CircleEdgeEffect& circleEffect = effect.cast<CircleEdgeEffect>
(); | 128 const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleE
dgeEffect>(); |
129 b->add32(circleEffect.isStroked()); | 129 b->add32(circleEffect.isStroked()); |
130 } | 130 } |
131 | 131 |
132 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_
OVERRIDE {} | 132 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&)
SK_OVERRIDE {} |
133 | 133 |
134 private: | 134 private: |
135 typedef GrGLGeometryProcessor INHERITED; | 135 typedef GrGLGeometryProcessor INHERITED; |
136 }; | 136 }; |
137 | 137 |
138 | 138 |
139 private: | 139 private: |
140 CircleEdgeEffect(bool stroke) | 140 CircleEdgeEffect(bool stroke) |
141 : fInCircleEdge(this->addVertexAttrib( | 141 : fInCircleEdge(this->addVertexAttrib( |
142 GrShaderVar("inCircleEdge", | 142 GrShaderVar("inCircleEdge", |
143 kVec4f_GrSLType, | 143 kVec4f_GrSLType, |
144 GrShaderVar::kAttribute_TypeModifier))) { | 144 GrShaderVar::kAttribute_TypeModifier))) { |
145 fStroke = stroke; | 145 fStroke = stroke; |
146 } | 146 } |
147 | 147 |
148 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { | 148 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { |
149 const CircleEdgeEffect& cee = other.cast<CircleEdgeEffect>(); | 149 const CircleEdgeEffect& cee = CastEffect<CircleEdgeEffect>(other); |
150 return cee.fStroke == fStroke; | 150 return cee.fStroke == fStroke; |
151 } | 151 } |
152 | 152 |
153 const GrShaderVar& fInCircleEdge; | 153 const GrShaderVar& fInCircleEdge; |
154 bool fStroke; | 154 bool fStroke; |
155 | 155 |
156 GR_DECLARE_EFFECT_TEST; | 156 GR_DECLARE_EFFECT_TEST; |
157 | 157 |
158 typedef GrGeometryProcessor INHERITED; | 158 typedef GrGeometryProcessor INHERITED; |
159 }; | 159 }; |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
205 | 205 |
206 static const char* Name() { return "EllipseEdge"; } | 206 static const char* Name() { return "EllipseEdge"; } |
207 | 207 |
208 const GrShaderVar& inEllipseOffset() const { return fInEllipseOffset; } | 208 const GrShaderVar& inEllipseOffset() const { return fInEllipseOffset; } |
209 const GrShaderVar& inEllipseRadii() const { return fInEllipseRadii; } | 209 const GrShaderVar& inEllipseRadii() const { return fInEllipseRadii; } |
210 | 210 |
211 inline bool isStroked() const { return fStroke; } | 211 inline bool isStroked() const { return fStroke; } |
212 | 212 |
213 class GLEffect : public GrGLGeometryProcessor { | 213 class GLEffect : public GrGLGeometryProcessor { |
214 public: | 214 public: |
215 GLEffect(const GrBackendEffectFactory& factory, const GrEffect&) | 215 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) |
216 : INHERITED (factory) {} | 216 : INHERITED (factory) {} |
217 | 217 |
218 virtual void emitCode(GrGLFullProgramBuilder* builder, | 218 virtual void emitCode(GrGLFullProgramBuilder* builder, |
219 const GrEffect& effect, | 219 const GrDrawEffect& drawEffect, |
220 const GrEffectKey& key, | 220 const GrEffectKey& key, |
221 const char* outputColor, | 221 const char* outputColor, |
222 const char* inputColor, | 222 const char* inputColor, |
223 const TransformedCoordsArray&, | 223 const TransformedCoordsArray&, |
224 const TextureSamplerArray& samplers) SK_OVERRIDE { | 224 const TextureSamplerArray& samplers) SK_OVERRIDE { |
225 const EllipseEdgeEffect& ellipseEffect = effect.cast<EllipseEdgeEffe
ct>(); | 225 const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<Ellip
seEdgeEffect>(); |
226 | 226 |
227 const char *vsOffsetName, *fsOffsetName; | 227 const char *vsOffsetName, *fsOffsetName; |
228 const char *vsRadiiName, *fsRadiiName; | 228 const char *vsRadiiName, *fsRadiiName; |
229 | 229 |
230 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets", &vsOffsetName
, &fsOffsetName); | 230 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets", &vsOffsetName
, &fsOffsetName); |
231 | 231 |
232 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder
(); | 232 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder
(); |
233 vsBuilder->codeAppendf("%s = %s;", vsOffsetName, | 233 vsBuilder->codeAppendf("%s = %s;", vsOffsetName, |
234 ellipseEffect.inEllipseOffset().c_str()); | 234 ellipseEffect.inEllipseOffset().c_str()); |
235 | 235 |
(...skipping 17 matching lines...) Expand all Loading... |
253 fsBuilder->codeAppend("\ttest = dot(scaledOffset, scaledOffset)
- 1.0;\n"); | 253 fsBuilder->codeAppend("\ttest = dot(scaledOffset, scaledOffset)
- 1.0;\n"); |
254 fsBuilder->codeAppendf("\tgrad = 2.0*scaledOffset*%s.zw;\n", fsR
adiiName); | 254 fsBuilder->codeAppendf("\tgrad = 2.0*scaledOffset*%s.zw;\n", fsR
adiiName); |
255 fsBuilder->codeAppend("\tinvlen = inversesqrt(dot(grad, grad));\
n"); | 255 fsBuilder->codeAppend("\tinvlen = inversesqrt(dot(grad, grad));\
n"); |
256 fsBuilder->codeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0
, 1.0);\n"); | 256 fsBuilder->codeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0
, 1.0);\n"); |
257 } | 257 } |
258 | 258 |
259 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, | 259 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, |
260 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); | 260 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); |
261 } | 261 } |
262 | 262 |
263 static void GenKey(const GrEffect& effect, const GrGLCaps&, | 263 static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
264 GrEffectKeyBuilder* b) { | 264 GrEffectKeyBuilder* b) { |
265 const EllipseEdgeEffect& ellipseEffect = effect.cast<EllipseEdgeEffe
ct>(); | 265 const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<Ellip
seEdgeEffect>(); |
266 b->add32(ellipseEffect.isStroked()); | 266 b->add32(ellipseEffect.isStroked()); |
267 } | 267 } |
268 | 268 |
269 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_
OVERRIDE { | 269 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&)
SK_OVERRIDE { |
270 } | 270 } |
271 | 271 |
272 private: | 272 private: |
273 typedef GrGLGeometryProcessor INHERITED; | 273 typedef GrGLGeometryProcessor INHERITED; |
274 }; | 274 }; |
275 | 275 |
276 private: | 276 private: |
277 EllipseEdgeEffect(bool stroke) | 277 EllipseEdgeEffect(bool stroke) |
278 : fInEllipseOffset(this->addVertexAttrib( | 278 : fInEllipseOffset(this->addVertexAttrib( |
279 GrShaderVar("inEllipseOffset", | 279 GrShaderVar("inEllipseOffset", |
280 kVec2f_GrSLType, | 280 kVec2f_GrSLType, |
281 GrShaderVar::kAttribute_TypeModifier))) | 281 GrShaderVar::kAttribute_TypeModifier))) |
282 , fInEllipseRadii(this->addVertexAttrib( | 282 , fInEllipseRadii(this->addVertexAttrib( |
283 GrShaderVar("inEllipseRadii", | 283 GrShaderVar("inEllipseRadii", |
284 kVec4f_GrSLType, | 284 kVec4f_GrSLType, |
285 GrShaderVar::kAttribute_TypeModifier))) { | 285 GrShaderVar::kAttribute_TypeModifier))) { |
286 fStroke = stroke; | 286 fStroke = stroke; |
287 } | 287 } |
288 | 288 |
289 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { | 289 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { |
290 const EllipseEdgeEffect& eee = other.cast<EllipseEdgeEffect>(); | 290 const EllipseEdgeEffect& eee = CastEffect<EllipseEdgeEffect>(other); |
291 return eee.fStroke == fStroke; | 291 return eee.fStroke == fStroke; |
292 } | 292 } |
293 | 293 |
294 const GrShaderVar& fInEllipseOffset; | 294 const GrShaderVar& fInEllipseOffset; |
295 const GrShaderVar& fInEllipseRadii; | 295 const GrShaderVar& fInEllipseRadii; |
296 bool fStroke; | 296 bool fStroke; |
297 | 297 |
298 GR_DECLARE_EFFECT_TEST; | 298 GR_DECLARE_EFFECT_TEST; |
299 | 299 |
300 typedef GrGeometryProcessor INHERITED; | 300 typedef GrGeometryProcessor INHERITED; |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
354 | 354 |
355 static const char* Name() { return "DIEllipseEdge"; } | 355 static const char* Name() { return "DIEllipseEdge"; } |
356 | 356 |
357 const GrShaderVar& inEllipseOffsets0() const { return fInEllipseOffsets0; } | 357 const GrShaderVar& inEllipseOffsets0() const { return fInEllipseOffsets0; } |
358 const GrShaderVar& inEllipseOffsets1() const { return fInEllipseOffsets1; } | 358 const GrShaderVar& inEllipseOffsets1() const { return fInEllipseOffsets1; } |
359 | 359 |
360 inline Mode getMode() const { return fMode; } | 360 inline Mode getMode() const { return fMode; } |
361 | 361 |
362 class GLEffect : public GrGLGeometryProcessor { | 362 class GLEffect : public GrGLGeometryProcessor { |
363 public: | 363 public: |
364 GLEffect(const GrBackendEffectFactory& factory, const GrEffect&) | 364 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) |
365 : INHERITED (factory) {} | 365 : INHERITED (factory) {} |
366 | 366 |
367 virtual void emitCode(GrGLFullProgramBuilder* builder, | 367 virtual void emitCode(GrGLFullProgramBuilder* builder, |
368 const GrEffect& effect, | 368 const GrDrawEffect& drawEffect, |
369 const GrEffectKey& key, | 369 const GrEffectKey& key, |
370 const char* outputColor, | 370 const char* outputColor, |
371 const char* inputColor, | 371 const char* inputColor, |
372 const TransformedCoordsArray&, | 372 const TransformedCoordsArray&, |
373 const TextureSamplerArray& samplers) SK_OVERRIDE { | 373 const TextureSamplerArray& samplers) SK_OVERRIDE { |
374 const DIEllipseEdgeEffect& ellipseEffect = effect.cast<DIEllipseEdge
Effect>(); | 374 const DIEllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<DIE
llipseEdgeEffect>(); |
375 | 375 |
376 const char *vsOffsetName0, *fsOffsetName0; | 376 const char *vsOffsetName0, *fsOffsetName0; |
377 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets0", | 377 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets0", |
378 &vsOffsetName0, &fsOffsetName0); | 378 &vsOffsetName0, &fsOffsetName0); |
379 | 379 |
380 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder
(); | 380 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder
(); |
381 vsBuilder->codeAppendf("%s = %s;", vsOffsetName0, | 381 vsBuilder->codeAppendf("%s = %s;", vsOffsetName0, |
382 ellipseEffect.inEllipseOffsets0().c_str()); | 382 ellipseEffect.inEllipseOffsets0().c_str()); |
383 const char *vsOffsetName1, *fsOffsetName1; | 383 const char *vsOffsetName1, *fsOffsetName1; |
384 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets1", | 384 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets1", |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
420 "\t 2.0*%s.x*duvdy.x + 2.0*%s.
y*duvdy.y);\n", | 420 "\t 2.0*%s.x*duvdy.x + 2.0*%s.
y*duvdy.y);\n", |
421 fsOffsetName1, fsOffsetName1, fsOffsetNam
e1, fsOffsetName1); | 421 fsOffsetName1, fsOffsetName1, fsOffsetNam
e1, fsOffsetName1); |
422 fsBuilder->codeAppend("\tinvlen = inversesqrt(dot(grad, grad));\
n"); | 422 fsBuilder->codeAppend("\tinvlen = inversesqrt(dot(grad, grad));\
n"); |
423 fsBuilder->codeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0
, 1.0);\n"); | 423 fsBuilder->codeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0
, 1.0);\n"); |
424 } | 424 } |
425 | 425 |
426 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, | 426 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, |
427 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); | 427 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); |
428 } | 428 } |
429 | 429 |
430 static void GenKey(const GrEffect& effect, const GrGLCaps&, | 430 static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
431 GrEffectKeyBuilder* b) { | 431 GrEffectKeyBuilder* b) { |
432 const DIEllipseEdgeEffect& ellipseEffect = effect.cast<DIEllipseEdge
Effect>(); | 432 const DIEllipseEdgeEffect& ellipseEffect = |
| 433 drawEffect.castEffect<DIEllipseEdgeEffect>(); |
433 | 434 |
434 b->add32(ellipseEffect.getMode()); | 435 b->add32(ellipseEffect.getMode()); |
435 } | 436 } |
436 | 437 |
437 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_
OVERRIDE { | 438 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&)
SK_OVERRIDE { |
438 } | 439 } |
439 | 440 |
440 private: | 441 private: |
441 typedef GrGLGeometryProcessor INHERITED; | 442 typedef GrGLGeometryProcessor INHERITED; |
442 }; | 443 }; |
443 | 444 |
444 private: | 445 private: |
445 DIEllipseEdgeEffect(Mode mode) | 446 DIEllipseEdgeEffect(Mode mode) |
446 : fInEllipseOffsets0(this->addVertexAttrib( | 447 : fInEllipseOffsets0(this->addVertexAttrib( |
447 GrShaderVar("inEllipseOffsets0", | 448 GrShaderVar("inEllipseOffsets0", |
448 kVec2f_GrSLType, | 449 kVec2f_GrSLType, |
449 GrShaderVar::kAttribute_TypeModifier))) | 450 GrShaderVar::kAttribute_TypeModifier))) |
450 , fInEllipseOffsets1(this->addVertexAttrib( | 451 , fInEllipseOffsets1(this->addVertexAttrib( |
451 GrShaderVar("inEllipseOffsets1", | 452 GrShaderVar("inEllipseOffsets1", |
452 kVec2f_GrSLType, | 453 kVec2f_GrSLType, |
453 GrShaderVar::kAttribute_TypeModifier))) { | 454 GrShaderVar::kAttribute_TypeModifier))) { |
454 fMode = mode; | 455 fMode = mode; |
455 } | 456 } |
456 | 457 |
457 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { | 458 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { |
458 const DIEllipseEdgeEffect& eee = other.cast<DIEllipseEdgeEffect>(); | 459 const DIEllipseEdgeEffect& eee = CastEffect<DIEllipseEdgeEffect>(other); |
459 return eee.fMode == fMode; | 460 return eee.fMode == fMode; |
460 } | 461 } |
461 | 462 |
462 const GrShaderVar& fInEllipseOffsets0; | 463 const GrShaderVar& fInEllipseOffsets0; |
463 const GrShaderVar& fInEllipseOffsets1; | 464 const GrShaderVar& fInEllipseOffsets1; |
464 Mode fMode; | 465 Mode fMode; |
465 | 466 |
466 GR_DECLARE_EFFECT_TEST; | 467 GR_DECLARE_EFFECT_TEST; |
467 | 468 |
468 typedef GrGeometryProcessor INHERITED; | 469 typedef GrGeometryProcessor INHERITED; |
(...skipping 766 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1235 | 1236 |
1236 // drop out the middle quad if we're stroked | 1237 // drop out the middle quad if we're stroked |
1237 int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 : | 1238 int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 : |
1238 SK_ARRAY_COUNT(gRRectIndices); | 1239 SK_ARRAY_COUNT(gRRectIndices); |
1239 target->setIndexSourceToBuffer(indexBuffer); | 1240 target->setIndexSourceToBuffer(indexBuffer); |
1240 target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 16, indexCnt, &bou
nds); | 1241 target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 16, indexCnt, &bou
nds); |
1241 } | 1242 } |
1242 | 1243 |
1243 return true; | 1244 return true; |
1244 } | 1245 } |
OLD | NEW |