OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 Google Inc. | 2 * Copyright 2012 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 "GrAARectRenderer.h" | 8 #include "GrAARectRenderer.h" |
9 #include "GrDefaultGeoProcFactory.h" | 9 #include "GrDefaultGeoProcFactory.h" |
10 #include "GrGeometryProcessor.h" | 10 #include "GrGeometryProcessor.h" |
11 #include "GrGpu.h" | 11 #include "GrGpu.h" |
12 #include "GrInvariantOutput.h" | 12 #include "GrInvariantOutput.h" |
13 #include "SkColorPriv.h" | 13 #include "SkColorPriv.h" |
14 #include "gl/GrGLProcessor.h" | 14 #include "gl/GrGLProcessor.h" |
15 #include "gl/GrGLGeometryProcessor.h" | 15 #include "gl/GrGLGeometryProcessor.h" |
16 #include "gl/builders/GrGLProgramBuilder.h" | 16 #include "gl/builders/GrGLProgramBuilder.h" |
17 | 17 |
18 /////////////////////////////////////////////////////////////////////////////// | 18 /////////////////////////////////////////////////////////////////////////////// |
19 | 19 |
20 namespace { | 20 namespace { |
21 // Should the coverage be multiplied into the color attrib or use a separate att
rib. | 21 // Should the coverage be multiplied into the color attrib or use a separate att
rib. |
22 enum CoverageAttribType { | 22 enum CoverageAttribType { |
23 kUseColor_CoverageAttribType, | 23 kUseColor_CoverageAttribType, |
24 kUseCoverage_CoverageAttribType, | 24 kUseCoverage_CoverageAttribType, |
25 }; | 25 }; |
26 } | 26 } |
27 | 27 |
28 static const GrGeometryProcessor* create_rect_gp(const GrDrawState& drawState, G
rColor color, | 28 static CoverageAttribType set_rect_attribs(GrDrawState* drawState, GrColor color
) { |
29 CoverageAttribType* type) { | |
30 uint32_t flags = GrDefaultGeoProcFactory::kColor_GPType; | 29 uint32_t flags = GrDefaultGeoProcFactory::kColor_GPType; |
31 const GrGeometryProcessor* gp; | 30 if (drawState->canTweakAlphaForCoverage()) { |
32 if (drawState.canTweakAlphaForCoverage()) { | 31 drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(color, f
lags))->unref(); |
33 gp = GrDefaultGeoProcFactory::Create(color, flags); | 32 SkASSERT(drawState->getGeometryProcessor()->getVertexStride() == |
34 SkASSERT(gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::Positi
onColorAttr)); | 33 sizeof(GrDefaultGeoProcFactory::PositionColorAttr)); |
35 *type = kUseColor_CoverageAttribType; | 34 return kUseColor_CoverageAttribType; |
36 } else { | 35 } else { |
37 flags |= GrDefaultGeoProcFactory::kCoverage_GPType; | 36 flags |= GrDefaultGeoProcFactory::kCoverage_GPType; |
38 gp = GrDefaultGeoProcFactory::Create(color, flags); | 37 drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create(color, f
lags))->unref(); |
39 SkASSERT(gp->getVertexStride()==sizeof(GrDefaultGeoProcFactory::Position
ColorCoverageAttr)); | 38 SkASSERT(drawState->getGeometryProcessor()->getVertexStride() == |
40 *type = kUseCoverage_CoverageAttribType; | 39 sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr)); |
| 40 return kUseCoverage_CoverageAttribType; |
41 } | 41 } |
42 return gp; | |
43 } | 42 } |
44 | 43 |
45 static void set_inset_fan(SkPoint* pts, size_t stride, | 44 static void set_inset_fan(SkPoint* pts, size_t stride, |
46 const SkRect& r, SkScalar dx, SkScalar dy) { | 45 const SkRect& r, SkScalar dx, SkScalar dy) { |
47 pts->setRectFan(r.fLeft + dx, r.fTop + dy, | 46 pts->setRectFan(r.fLeft + dx, r.fTop + dy, |
48 r.fRight - dx, r.fBottom - dy, stride); | 47 r.fRight - dx, r.fBottom - dy, stride); |
49 } | 48 } |
50 | 49 |
51 void GrAARectRenderer::reset() { | 50 void GrAARectRenderer::reset() { |
52 SkSafeSetNull(fAAFillRectIndexBuffer); | 51 SkSafeSetNull(fAAFillRectIndexBuffer); |
(...skipping 123 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
176 } | 175 } |
177 | 176 |
178 void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target, | 177 void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target, |
179 GrDrawState* drawState, | 178 GrDrawState* drawState, |
180 GrColor color, | 179 GrColor color, |
181 const SkRect& rect, | 180 const SkRect& rect, |
182 const SkMatrix& combinedMatrix, | 181 const SkMatrix& combinedMatrix, |
183 const SkRect& devRect) { | 182 const SkRect& devRect) { |
184 GrDrawState::AutoRestoreEffects are(drawState); | 183 GrDrawState::AutoRestoreEffects are(drawState); |
185 | 184 |
186 CoverageAttribType type; | 185 CoverageAttribType covAttribType = set_rect_attribs(drawState, color); |
187 SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color,
&type)); | 186 if (kUseCoverage_CoverageAttribType == covAttribType && GrColorIsOpaque(colo
r)) { |
188 if (kUseCoverage_CoverageAttribType == type && GrColorIsOpaque(color)) { | |
189 drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true); | 187 drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true); |
190 } | 188 } |
191 | 189 |
192 size_t vertexStride = gp->getVertexStride(); | 190 size_t vstride = drawState->getGeometryProcessor()->getVertexStride(); |
193 GrDrawTarget::AutoReleaseGeometry geo(target, 8, vertexStride, 0); | 191 GrDrawTarget::AutoReleaseGeometry geo(target, 8, vstride, 0); |
194 if (!geo.succeeded()) { | 192 if (!geo.succeeded()) { |
195 SkDebugf("Failed to get space for vertices!\n"); | 193 SkDebugf("Failed to get space for vertices!\n"); |
196 return; | 194 return; |
197 } | 195 } |
198 | 196 |
199 if (NULL == fAAFillRectIndexBuffer) { | 197 if (NULL == fAAFillRectIndexBuffer) { |
200 fAAFillRectIndexBuffer = fGpu->createInstancedIndexBuffer(gFillAARectIdx
, | 198 fAAFillRectIndexBuffer = fGpu->createInstancedIndexBuffer(gFillAARectIdx
, |
201 kIndicesPerAAF
illRect, | 199 kIndicesPerAAF
illRect, |
202 kNumAAFillRect
sInIndexBuffer, | 200 kNumAAFillRect
sInIndexBuffer, |
203 kVertsPerAAFil
lRect); | 201 kVertsPerAAFil
lRect); |
204 } | 202 } |
205 GrIndexBuffer* indexBuffer = fAAFillRectIndexBuffer; | 203 GrIndexBuffer* indexBuffer = fAAFillRectIndexBuffer; |
206 if (NULL == indexBuffer) { | 204 if (NULL == indexBuffer) { |
207 SkDebugf("Failed to create index buffer!\n"); | 205 SkDebugf("Failed to create index buffer!\n"); |
208 return; | 206 return; |
209 } | 207 } |
210 | 208 |
211 intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices()); | 209 intptr_t verts = reinterpret_cast<intptr_t>(geo.vertices()); |
212 | 210 |
213 SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts); | 211 SkPoint* fan0Pos = reinterpret_cast<SkPoint*>(verts); |
214 SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + 4 * vertexStride); | 212 SkPoint* fan1Pos = reinterpret_cast<SkPoint*>(verts + 4 * vstride); |
215 | 213 |
216 SkScalar inset = SkMinScalar(devRect.width(), SK_Scalar1); | 214 SkScalar inset = SkMinScalar(devRect.width(), SK_Scalar1); |
217 inset = SK_ScalarHalf * SkMinScalar(inset, devRect.height()); | 215 inset = SK_ScalarHalf * SkMinScalar(inset, devRect.height()); |
218 | 216 |
219 if (combinedMatrix.rectStaysRect()) { | 217 if (combinedMatrix.rectStaysRect()) { |
220 // Temporarily #if'ed out. We don't want to pass in the devRect but | 218 // Temporarily #if'ed out. We don't want to pass in the devRect but |
221 // right now it is computed in GrContext::apply_aa_to_rect and we don't | 219 // right now it is computed in GrContext::apply_aa_to_rect and we don't |
222 // want to throw away the work | 220 // want to throw away the work |
223 #if 0 | 221 #if 0 |
224 SkRect devRect; | 222 SkRect devRect; |
225 combinedMatrix.mapRect(&devRect, rect); | 223 combinedMatrix.mapRect(&devRect, rect); |
226 #endif | 224 #endif |
227 | 225 |
228 set_inset_fan(fan0Pos, vertexStride, devRect, -SK_ScalarHalf, -SK_Scalar
Half); | 226 set_inset_fan(fan0Pos, vstride, devRect, -SK_ScalarHalf, -SK_ScalarHalf)
; |
229 set_inset_fan(fan1Pos, vertexStride, devRect, inset, inset); | 227 set_inset_fan(fan1Pos, vstride, devRect, inset, inset); |
230 } else { | 228 } else { |
231 // compute transformed (1, 0) and (0, 1) vectors | 229 // compute transformed (1, 0) and (0, 1) vectors |
232 SkVector vec[2] = { | 230 SkVector vec[2] = { |
233 { combinedMatrix[SkMatrix::kMScaleX], combinedMatrix[SkMatrix::kMSkewY
] }, | 231 { combinedMatrix[SkMatrix::kMScaleX], combinedMatrix[SkMatrix::kMSkewY
] }, |
234 { combinedMatrix[SkMatrix::kMSkewX], combinedMatrix[SkMatrix::kMScale
Y] } | 232 { combinedMatrix[SkMatrix::kMSkewX], combinedMatrix[SkMatrix::kMScale
Y] } |
235 }; | 233 }; |
236 | 234 |
237 vec[0].normalize(); | 235 vec[0].normalize(); |
238 vec[0].scale(SK_ScalarHalf); | 236 vec[0].scale(SK_ScalarHalf); |
239 vec[1].normalize(); | 237 vec[1].normalize(); |
240 vec[1].scale(SK_ScalarHalf); | 238 vec[1].scale(SK_ScalarHalf); |
241 | 239 |
242 // create the rotated rect | 240 // create the rotated rect |
243 fan0Pos->setRectFan(rect.fLeft, rect.fTop, | 241 fan0Pos->setRectFan(rect.fLeft, rect.fTop, |
244 rect.fRight, rect.fBottom, vertexStride); | 242 rect.fRight, rect.fBottom, vstride); |
245 combinedMatrix.mapPointsWithStride(fan0Pos, vertexStride, 4); | 243 combinedMatrix.mapPointsWithStride(fan0Pos, vstride, 4); |
246 | 244 |
247 // Now create the inset points and then outset the original | 245 // Now create the inset points and then outset the original |
248 // rotated points | 246 // rotated points |
249 | 247 |
250 // TL | 248 // TL |
251 *((SkPoint*)((intptr_t)fan1Pos + 0 * vertexStride)) = | 249 *((SkPoint*)((intptr_t)fan1Pos + 0 * vstride)) = |
252 *((SkPoint*)((intptr_t)fan0Pos + 0 * vertexStride)) + vec[0] + vec[1
]; | 250 *((SkPoint*)((intptr_t)fan0Pos + 0 * vstride)) + vec[0] + vec[1]; |
253 *((SkPoint*)((intptr_t)fan0Pos + 0 * vertexStride)) -= vec[0] + vec[1]; | 251 *((SkPoint*)((intptr_t)fan0Pos + 0 * vstride)) -= vec[0] + vec[1]; |
254 // BL | 252 // BL |
255 *((SkPoint*)((intptr_t)fan1Pos + 1 * vertexStride)) = | 253 *((SkPoint*)((intptr_t)fan1Pos + 1 * vstride)) = |
256 *((SkPoint*)((intptr_t)fan0Pos + 1 * vertexStride)) + vec[0] - vec[1
]; | 254 *((SkPoint*)((intptr_t)fan0Pos + 1 * vstride)) + vec[0] - vec[1]; |
257 *((SkPoint*)((intptr_t)fan0Pos + 1 * vertexStride)) -= vec[0] - vec[1]; | 255 *((SkPoint*)((intptr_t)fan0Pos + 1 * vstride)) -= vec[0] - vec[1]; |
258 // BR | 256 // BR |
259 *((SkPoint*)((intptr_t)fan1Pos + 2 * vertexStride)) = | 257 *((SkPoint*)((intptr_t)fan1Pos + 2 * vstride)) = |
260 *((SkPoint*)((intptr_t)fan0Pos + 2 * vertexStride)) - vec[0] - vec[1
]; | 258 *((SkPoint*)((intptr_t)fan0Pos + 2 * vstride)) - vec[0] - vec[1]; |
261 *((SkPoint*)((intptr_t)fan0Pos + 2 * vertexStride)) += vec[0] + vec[1]; | 259 *((SkPoint*)((intptr_t)fan0Pos + 2 * vstride)) += vec[0] + vec[1]; |
262 // TR | 260 // TR |
263 *((SkPoint*)((intptr_t)fan1Pos + 3 * vertexStride)) = | 261 *((SkPoint*)((intptr_t)fan1Pos + 3 * vstride)) = |
264 *((SkPoint*)((intptr_t)fan0Pos + 3 * vertexStride)) - vec[0] + vec[1
]; | 262 *((SkPoint*)((intptr_t)fan0Pos + 3 * vstride)) - vec[0] + vec[1]; |
265 *((SkPoint*)((intptr_t)fan0Pos + 3 * vertexStride)) += vec[0] - vec[1]; | 263 *((SkPoint*)((intptr_t)fan0Pos + 3 * vstride)) += vec[0] - vec[1]; |
266 } | 264 } |
267 | 265 |
268 // Make verts point to vertex color and then set all the color and coverage
vertex attrs values. | 266 // Make verts point to vertex color and then set all the color and coverage
vertex attrs values. |
269 verts += sizeof(SkPoint); | 267 verts += sizeof(SkPoint); |
270 for (int i = 0; i < 4; ++i) { | 268 for (int i = 0; i < 4; ++i) { |
271 if (kUseCoverage_CoverageAttribType == type) { | 269 if (kUseCoverage_CoverageAttribType == covAttribType) { |
272 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color; | 270 *reinterpret_cast<GrColor*>(verts + i * vstride) = color; |
273 *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)
) = 0; | 271 *reinterpret_cast<float*>(verts + i * vstride + sizeof(GrColor)) = 0
; |
274 } else { | 272 } else { |
275 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = 0; | 273 *reinterpret_cast<GrColor*>(verts + i * vstride) = 0; |
276 } | 274 } |
277 } | 275 } |
278 | 276 |
279 int scale; | 277 int scale; |
280 if (inset < SK_ScalarHalf) { | 278 if (inset < SK_ScalarHalf) { |
281 scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf)); | 279 scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf)); |
282 SkASSERT(scale >= 0 && scale <= 255); | 280 SkASSERT(scale >= 0 && scale <= 255); |
283 } else { | 281 } else { |
284 scale = 0xff; | 282 scale = 0xff; |
285 } | 283 } |
286 | 284 |
287 verts += 4 * vertexStride; | 285 verts += 4 * vstride; |
288 | 286 |
289 float innerCoverage = GrNormalizeByteToFloat(scale); | 287 float innerCoverage = GrNormalizeByteToFloat(scale); |
290 GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale); | 288 GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale); |
291 | 289 |
292 for (int i = 0; i < 4; ++i) { | 290 for (int i = 0; i < 4; ++i) { |
293 if (kUseCoverage_CoverageAttribType == type) { | 291 if (kUseCoverage_CoverageAttribType == covAttribType) { |
294 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color; | 292 *reinterpret_cast<GrColor*>(verts + i * vstride) = color; |
295 *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)
) = innerCoverage; | 293 *reinterpret_cast<float*>(verts + i * vstride + sizeof(GrColor)) = i
nnerCoverage; |
296 } else { | 294 } else { |
297 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor; | 295 *reinterpret_cast<GrColor*>(verts + i * vstride) = scaledColor; |
298 } | 296 } |
299 } | 297 } |
300 | 298 |
301 target->setIndexSourceToBuffer(indexBuffer); | 299 target->setIndexSourceToBuffer(indexBuffer); |
302 target->drawIndexedInstances(drawState, | 300 target->drawIndexedInstances(drawState, |
303 gp, | |
304 kTriangles_GrPrimitiveType, | 301 kTriangles_GrPrimitiveType, |
305 1, | 302 1, |
306 kVertsPerAAFillRect, | 303 kVertsPerAAFillRect, |
307 kIndicesPerAAFillRect); | 304 kIndicesPerAAFillRect); |
308 target->resetIndexSource(); | 305 target->resetIndexSource(); |
309 } | 306 } |
310 | 307 |
311 void GrAARectRenderer::strokeAARect(GrDrawTarget* target, | 308 void GrAARectRenderer::strokeAARect(GrDrawTarget* target, |
312 GrDrawState* drawState, | 309 GrDrawState* drawState, |
313 GrColor color, | 310 GrColor color, |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
379 } | 376 } |
380 | 377 |
381 void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target, | 378 void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target, |
382 GrDrawState* drawState, | 379 GrDrawState* drawState, |
383 GrColor color, | 380 GrColor color, |
384 const SkRect& devOutside, | 381 const SkRect& devOutside, |
385 const SkRect& devOutsideAssist, | 382 const SkRect& devOutsideAssist, |
386 const SkRect& devInside, | 383 const SkRect& devInside, |
387 bool miterStroke) { | 384 bool miterStroke) { |
388 GrDrawState::AutoRestoreEffects are(drawState); | 385 GrDrawState::AutoRestoreEffects are(drawState); |
| 386 CoverageAttribType covAttribType = set_rect_attribs(drawState, color); |
389 | 387 |
390 CoverageAttribType type; | 388 if (kUseCoverage_CoverageAttribType == covAttribType && GrColorIsOpaque(colo
r)) { |
391 SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color,
&type)); | |
392 | |
393 if (kUseCoverage_CoverageAttribType == type && GrColorIsOpaque(color)) { | |
394 drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true); | 389 drawState->setHint(GrDrawState::kVertexColorsAreOpaque_Hint, true); |
395 } | 390 } |
396 | 391 |
397 int innerVertexNum = 4; | 392 int innerVertexNum = 4; |
398 int outerVertexNum = miterStroke ? 4 : 8; | 393 int outerVertexNum = miterStroke ? 4 : 8; |
399 int totalVertexNum = (outerVertexNum + innerVertexNum) * 2; | 394 int totalVertexNum = (outerVertexNum + innerVertexNum) * 2; |
400 | 395 |
401 size_t vstride = gp->getVertexStride(); | 396 size_t vstride = drawState->getGeometryProcessor()->getVertexStride(); |
402 GrDrawTarget::AutoReleaseGeometry geo(target, totalVertexNum, vstride, 0); | 397 GrDrawTarget::AutoReleaseGeometry geo(target, totalVertexNum, vstride, 0); |
403 if (!geo.succeeded()) { | 398 if (!geo.succeeded()) { |
404 SkDebugf("Failed to get space for vertices!\n"); | 399 SkDebugf("Failed to get space for vertices!\n"); |
405 return; | 400 return; |
406 } | 401 } |
407 GrIndexBuffer* indexBuffer = this->aaStrokeRectIndexBuffer(miterStroke); | 402 GrIndexBuffer* indexBuffer = this->aaStrokeRectIndexBuffer(miterStroke); |
408 if (NULL == indexBuffer) { | 403 if (NULL == indexBuffer) { |
409 SkDebugf("Failed to create index buffer!\n"); | 404 SkDebugf("Failed to create index buffer!\n"); |
410 return; | 405 return; |
411 } | 406 } |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
456 // inner one of the inner two | 451 // inner one of the inner two |
457 set_inset_fan(fan2Pos, vstride, devInside, -inset, -inset); | 452 set_inset_fan(fan2Pos, vstride, devInside, -inset, -inset); |
458 // innermost | 453 // innermost |
459 set_inset_fan(fan3Pos, vstride, devInside, SK_ScalarHalf, SK_ScalarHa
lf); | 454 set_inset_fan(fan3Pos, vstride, devInside, SK_ScalarHalf, SK_ScalarHa
lf); |
460 } | 455 } |
461 | 456 |
462 // Make verts point to vertex color and then set all the color and coverage
vertex attrs values. | 457 // Make verts point to vertex color and then set all the color and coverage
vertex attrs values. |
463 // The outermost rect has 0 coverage | 458 // The outermost rect has 0 coverage |
464 verts += sizeof(SkPoint); | 459 verts += sizeof(SkPoint); |
465 for (int i = 0; i < outerVertexNum; ++i) { | 460 for (int i = 0; i < outerVertexNum; ++i) { |
466 if (kUseCoverage_CoverageAttribType == type) { | 461 if (kUseCoverage_CoverageAttribType == covAttribType) { |
467 *reinterpret_cast<GrColor*>(verts + i * vstride) = color; | 462 *reinterpret_cast<GrColor*>(verts + i * vstride) = color; |
468 *reinterpret_cast<float*>(verts + i * vstride + sizeof(GrColor)) = 0
; | 463 *reinterpret_cast<float*>(verts + i * vstride + sizeof(GrColor)) = 0
; |
469 } else { | 464 } else { |
470 *reinterpret_cast<GrColor*>(verts + i * vstride) = 0; | 465 *reinterpret_cast<GrColor*>(verts + i * vstride) = 0; |
471 } | 466 } |
472 } | 467 } |
473 | 468 |
474 // scale is the coverage for the the inner two rects. | 469 // scale is the coverage for the the inner two rects. |
475 int scale; | 470 int scale; |
476 if (inset < SK_ScalarHalf) { | 471 if (inset < SK_ScalarHalf) { |
477 scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf)); | 472 scale = SkScalarFloorToInt(512.0f * inset / (inset + SK_ScalarHalf)); |
478 SkASSERT(scale >= 0 && scale <= 255); | 473 SkASSERT(scale >= 0 && scale <= 255); |
479 } else { | 474 } else { |
480 scale = 0xff; | 475 scale = 0xff; |
481 } | 476 } |
482 | 477 |
483 float innerCoverage = GrNormalizeByteToFloat(scale); | 478 float innerCoverage = GrNormalizeByteToFloat(scale); |
484 GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale); | 479 GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale); |
485 | 480 |
486 verts += outerVertexNum * vstride; | 481 verts += outerVertexNum * vstride; |
487 for (int i = 0; i < outerVertexNum + innerVertexNum; ++i) { | 482 for (int i = 0; i < outerVertexNum + innerVertexNum; ++i) { |
488 if (kUseCoverage_CoverageAttribType == type) { | 483 if (kUseCoverage_CoverageAttribType == covAttribType) { |
489 *reinterpret_cast<GrColor*>(verts + i * vstride) = color; | 484 *reinterpret_cast<GrColor*>(verts + i * vstride) = color; |
490 *reinterpret_cast<float*>(verts + i * vstride + sizeof(GrColor)) = i
nnerCoverage; | 485 *reinterpret_cast<float*>(verts + i * vstride + sizeof(GrColor)) = i
nnerCoverage; |
491 } else { | 486 } else { |
492 *reinterpret_cast<GrColor*>(verts + i * vstride) = scaledColor; | 487 *reinterpret_cast<GrColor*>(verts + i * vstride) = scaledColor; |
493 } | 488 } |
494 } | 489 } |
495 | 490 |
496 // The innermost rect has 0 coverage | 491 // The innermost rect has 0 coverage |
497 verts += (outerVertexNum + innerVertexNum) * vstride; | 492 verts += (outerVertexNum + innerVertexNum) * vstride; |
498 for (int i = 0; i < innerVertexNum; ++i) { | 493 for (int i = 0; i < innerVertexNum; ++i) { |
499 if (kUseCoverage_CoverageAttribType == type) { | 494 if (kUseCoverage_CoverageAttribType == covAttribType) { |
500 *reinterpret_cast<GrColor*>(verts + i * vstride) = color; | 495 *reinterpret_cast<GrColor*>(verts + i * vstride) = color; |
501 *reinterpret_cast<GrColor*>(verts + i * vstride + sizeof(GrColor)) =
0; | 496 *reinterpret_cast<GrColor*>(verts + i * vstride + sizeof(GrColor)) =
0; |
502 } else { | 497 } else { |
503 *reinterpret_cast<GrColor*>(verts + i * vstride) = 0; | 498 *reinterpret_cast<GrColor*>(verts + i * vstride) = 0; |
504 } | 499 } |
505 } | 500 } |
506 | 501 |
507 target->setIndexSourceToBuffer(indexBuffer); | 502 target->setIndexSourceToBuffer(indexBuffer); |
508 target->drawIndexedInstances(drawState, | 503 target->drawIndexedInstances(drawState, |
509 gp, | |
510 kTriangles_GrPrimitiveType, | 504 kTriangles_GrPrimitiveType, |
511 1, | 505 1, |
512 totalVertexNum, | 506 totalVertexNum, |
513 aa_stroke_rect_index_count(miterStroke)); | 507 aa_stroke_rect_index_count(miterStroke)); |
514 target->resetIndexSource(); | 508 target->resetIndexSource(); |
515 } | 509 } |
516 | 510 |
517 void GrAARectRenderer::fillAANestedRects(GrDrawTarget* target, | 511 void GrAARectRenderer::fillAANestedRects(GrDrawTarget* target, |
518 GrDrawState* drawState, | 512 GrDrawState* drawState, |
519 GrColor color, | 513 GrColor color, |
520 const SkRect rects[2], | 514 const SkRect rects[2], |
521 const SkMatrix& combinedMatrix) { | 515 const SkMatrix& combinedMatrix) { |
522 SkASSERT(combinedMatrix.rectStaysRect()); | 516 SkASSERT(combinedMatrix.rectStaysRect()); |
523 SkASSERT(!rects[1].isEmpty()); | 517 SkASSERT(!rects[1].isEmpty()); |
524 | 518 |
525 SkRect devOutside, devOutsideAssist, devInside; | 519 SkRect devOutside, devOutsideAssist, devInside; |
526 combinedMatrix.mapRect(&devOutside, rects[0]); | 520 combinedMatrix.mapRect(&devOutside, rects[0]); |
527 // can't call mapRect for devInside since it calls sort | 521 // can't call mapRect for devInside since it calls sort |
528 combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2)
; | 522 combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2)
; |
529 | 523 |
530 if (devInside.isEmpty()) { | 524 if (devInside.isEmpty()) { |
531 this->fillAARect(target, drawState, color, devOutside, SkMatrix::I(), de
vOutside); | 525 this->fillAARect(target, drawState, color, devOutside, SkMatrix::I(), de
vOutside); |
532 return; | 526 return; |
533 } | 527 } |
534 | 528 |
535 this->geometryStrokeAARect(target, drawState, color, devOutside, devOutsideA
ssist, devInside, | 529 this->geometryStrokeAARect(target, drawState, color, devOutside, devOutsideA
ssist, devInside, |
536 true); | 530 true); |
537 } | 531 } |
OLD | NEW |