GrDrawTarget.cpp revision 2a05de0c049a8648942a55016126a1f92e1c14d6
1 2/* 3 * Copyright 2010 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9 10 11#include "GrDrawTarget.h" 12#include "GrContext.h" 13#include "GrDrawTargetCaps.h" 14#include "GrPath.h" 15#include "GrRenderTarget.h" 16#include "GrTexture.h" 17#include "GrVertexBuffer.h" 18 19#include "SkStrokeRec.h" 20 21//////////////////////////////////////////////////////////////////////////////// 22 23GrDrawTarget::DrawInfo& GrDrawTarget::DrawInfo::operator =(const DrawInfo& di) { 24 fPrimitiveType = di.fPrimitiveType; 25 fStartVertex = di.fStartVertex; 26 fStartIndex = di.fStartIndex; 27 fVertexCount = di.fVertexCount; 28 fIndexCount = di.fIndexCount; 29 30 fInstanceCount = di.fInstanceCount; 31 fVerticesPerInstance = di.fVerticesPerInstance; 32 fIndicesPerInstance = di.fIndicesPerInstance; 33 34 if (NULL != di.fDevBounds) { 35 SkASSERT(di.fDevBounds == &di.fDevBoundsStorage); 36 fDevBoundsStorage = di.fDevBoundsStorage; 37 fDevBounds = &fDevBoundsStorage; 38 } else { 39 fDevBounds = NULL; 40 } 41 42 fDstCopy = di.fDstCopy; 43 44 return *this; 45} 46 47#ifdef SK_DEBUG 48bool GrDrawTarget::DrawInfo::isInstanced() const { 49 if (fInstanceCount > 0) { 50 SkASSERT(0 == fIndexCount % fIndicesPerInstance); 51 SkASSERT(0 == fVertexCount % fVerticesPerInstance); 52 SkASSERT(fIndexCount / fIndicesPerInstance == fInstanceCount); 53 SkASSERT(fVertexCount / fVerticesPerInstance == fInstanceCount); 54 // there is no way to specify a non-zero start index to drawIndexedInstances(). 55 SkASSERT(0 == fStartIndex); 56 return true; 57 } else { 58 SkASSERT(!fVerticesPerInstance); 59 SkASSERT(!fIndicesPerInstance); 60 return false; 61 } 62} 63#endif 64 65void GrDrawTarget::DrawInfo::adjustInstanceCount(int instanceOffset) { 66 SkASSERT(this->isInstanced()); 67 SkASSERT(instanceOffset + fInstanceCount >= 0); 68 fInstanceCount += instanceOffset; 69 fVertexCount = fVerticesPerInstance * fInstanceCount; 70 fIndexCount = fIndicesPerInstance * fInstanceCount; 71} 72 73void GrDrawTarget::DrawInfo::adjustStartVertex(int vertexOffset) { 74 fStartVertex += vertexOffset; 75 SkASSERT(fStartVertex >= 0); 76} 77 78void GrDrawTarget::DrawInfo::adjustStartIndex(int indexOffset) { 79 SkASSERT(this->isIndexed()); 80 fStartIndex += indexOffset; 81 SkASSERT(fStartIndex >= 0); 82} 83 84//////////////////////////////////////////////////////////////////////////////// 85 86#define DEBUG_INVAL_BUFFER 0xdeadcafe 87#define DEBUG_INVAL_START_IDX -1 88 89GrDrawTarget::GrDrawTarget(GrContext* context) 90 : fClip(NULL) 91 , fContext(context) 92 , fGpuTraceMarkerCount(0) { 93 SkASSERT(NULL != context); 94 95 fDrawState = &fDefaultDrawState; 96 // We assume that fDrawState always owns a ref to the object it points at. 97 fDefaultDrawState.ref(); 98 GeometrySrcState& geoSrc = fGeoSrcStateStack.push_back(); 99#ifdef SK_DEBUG 100 geoSrc.fVertexCount = DEBUG_INVAL_START_IDX; 101 geoSrc.fVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER; 102 geoSrc.fIndexCount = DEBUG_INVAL_START_IDX; 103 geoSrc.fIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER; 104#endif 105 geoSrc.fVertexSrc = kNone_GeometrySrcType; 106 geoSrc.fIndexSrc = kNone_GeometrySrcType; 107} 108 109GrDrawTarget::~GrDrawTarget() { 110 SkASSERT(1 == fGeoSrcStateStack.count()); 111 SkDEBUGCODE(GeometrySrcState& geoSrc = fGeoSrcStateStack.back()); 112 SkASSERT(kNone_GeometrySrcType == geoSrc.fIndexSrc); 113 SkASSERT(kNone_GeometrySrcType == geoSrc.fVertexSrc); 114 fDrawState->unref(); 115} 116 117void GrDrawTarget::releaseGeometry() { 118 int popCnt = fGeoSrcStateStack.count() - 1; 119 while (popCnt) { 120 this->popGeometrySource(); 121 --popCnt; 122 } 123 this->resetVertexSource(); 124 this->resetIndexSource(); 125} 126 127void GrDrawTarget::setClip(const GrClipData* clip) { 128 clipWillBeSet(clip); 129 fClip = clip; 130} 131 132const GrClipData* GrDrawTarget::getClip() const { 133 return fClip; 134} 135 136void GrDrawTarget::setDrawState(GrDrawState* drawState) { 137 SkASSERT(NULL != fDrawState); 138 if (NULL == drawState) { 139 drawState = &fDefaultDrawState; 140 } 141 if (fDrawState != drawState) { 142 fDrawState->unref(); 143 drawState->ref(); 144 fDrawState = drawState; 145 } 146} 147 148bool GrDrawTarget::reserveVertexSpace(size_t vertexSize, 149 int vertexCount, 150 void** vertices) { 151 GeometrySrcState& geoSrc = fGeoSrcStateStack.back(); 152 bool acquired = false; 153 if (vertexCount > 0) { 154 SkASSERT(NULL != vertices); 155 this->releasePreviousVertexSource(); 156 geoSrc.fVertexSrc = kNone_GeometrySrcType; 157 158 acquired = this->onReserveVertexSpace(vertexSize, 159 vertexCount, 160 vertices); 161 } 162 if (acquired) { 163 geoSrc.fVertexSrc = kReserved_GeometrySrcType; 164 geoSrc.fVertexCount = vertexCount; 165 geoSrc.fVertexSize = vertexSize; 166 } else if (NULL != vertices) { 167 *vertices = NULL; 168 } 169 return acquired; 170} 171 172bool GrDrawTarget::reserveIndexSpace(int indexCount, 173 void** indices) { 174 GeometrySrcState& geoSrc = fGeoSrcStateStack.back(); 175 bool acquired = false; 176 if (indexCount > 0) { 177 SkASSERT(NULL != indices); 178 this->releasePreviousIndexSource(); 179 geoSrc.fIndexSrc = kNone_GeometrySrcType; 180 181 acquired = this->onReserveIndexSpace(indexCount, indices); 182 } 183 if (acquired) { 184 geoSrc.fIndexSrc = kReserved_GeometrySrcType; 185 geoSrc.fIndexCount = indexCount; 186 } else if (NULL != indices) { 187 *indices = NULL; 188 } 189 return acquired; 190 191} 192 193bool GrDrawTarget::reserveVertexAndIndexSpace(int vertexCount, 194 int indexCount, 195 void** vertices, 196 void** indices) { 197 size_t vertexSize = this->drawState()->getVertexSize(); 198 this->willReserveVertexAndIndexSpace(vertexCount, indexCount); 199 if (vertexCount) { 200 if (!this->reserveVertexSpace(vertexSize, vertexCount, vertices)) { 201 if (indexCount) { 202 this->resetIndexSource(); 203 } 204 return false; 205 } 206 } 207 if (indexCount) { 208 if (!this->reserveIndexSpace(indexCount, indices)) { 209 if (vertexCount) { 210 this->resetVertexSource(); 211 } 212 return false; 213 } 214 } 215 return true; 216} 217 218bool GrDrawTarget::geometryHints(int32_t* vertexCount, 219 int32_t* indexCount) const { 220 if (NULL != vertexCount) { 221 *vertexCount = -1; 222 } 223 if (NULL != indexCount) { 224 *indexCount = -1; 225 } 226 return false; 227} 228 229void GrDrawTarget::releasePreviousVertexSource() { 230 GeometrySrcState& geoSrc = fGeoSrcStateStack.back(); 231 switch (geoSrc.fVertexSrc) { 232 case kNone_GeometrySrcType: 233 break; 234 case kArray_GeometrySrcType: 235 this->releaseVertexArray(); 236 break; 237 case kReserved_GeometrySrcType: 238 this->releaseReservedVertexSpace(); 239 break; 240 case kBuffer_GeometrySrcType: 241 geoSrc.fVertexBuffer->unref(); 242#ifdef SK_DEBUG 243 geoSrc.fVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER; 244#endif 245 break; 246 default: 247 GrCrash("Unknown Vertex Source Type."); 248 break; 249 } 250} 251 252void GrDrawTarget::releasePreviousIndexSource() { 253 GeometrySrcState& geoSrc = fGeoSrcStateStack.back(); 254 switch (geoSrc.fIndexSrc) { 255 case kNone_GeometrySrcType: // these two don't require 256 break; 257 case kArray_GeometrySrcType: 258 this->releaseIndexArray(); 259 break; 260 case kReserved_GeometrySrcType: 261 this->releaseReservedIndexSpace(); 262 break; 263 case kBuffer_GeometrySrcType: 264 geoSrc.fIndexBuffer->unref(); 265#ifdef SK_DEBUG 266 geoSrc.fIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER; 267#endif 268 break; 269 default: 270 GrCrash("Unknown Index Source Type."); 271 break; 272 } 273} 274 275void GrDrawTarget::setVertexSourceToArray(const void* vertexArray, 276 int vertexCount) { 277 this->releasePreviousVertexSource(); 278 GeometrySrcState& geoSrc = fGeoSrcStateStack.back(); 279 geoSrc.fVertexSrc = kArray_GeometrySrcType; 280 geoSrc.fVertexSize = this->drawState()->getVertexSize(); 281 geoSrc.fVertexCount = vertexCount; 282 this->onSetVertexSourceToArray(vertexArray, vertexCount); 283} 284 285void GrDrawTarget::setIndexSourceToArray(const void* indexArray, 286 int indexCount) { 287 this->releasePreviousIndexSource(); 288 GeometrySrcState& geoSrc = fGeoSrcStateStack.back(); 289 geoSrc.fIndexSrc = kArray_GeometrySrcType; 290 geoSrc.fIndexCount = indexCount; 291 this->onSetIndexSourceToArray(indexArray, indexCount); 292} 293 294void GrDrawTarget::setVertexSourceToBuffer(const GrVertexBuffer* buffer) { 295 this->releasePreviousVertexSource(); 296 GeometrySrcState& geoSrc = fGeoSrcStateStack.back(); 297 geoSrc.fVertexSrc = kBuffer_GeometrySrcType; 298 geoSrc.fVertexBuffer = buffer; 299 buffer->ref(); 300 geoSrc.fVertexSize = this->drawState()->getVertexSize(); 301} 302 303void GrDrawTarget::setIndexSourceToBuffer(const GrIndexBuffer* buffer) { 304 this->releasePreviousIndexSource(); 305 GeometrySrcState& geoSrc = fGeoSrcStateStack.back(); 306 geoSrc.fIndexSrc = kBuffer_GeometrySrcType; 307 geoSrc.fIndexBuffer = buffer; 308 buffer->ref(); 309} 310 311void GrDrawTarget::resetVertexSource() { 312 this->releasePreviousVertexSource(); 313 GeometrySrcState& geoSrc = fGeoSrcStateStack.back(); 314 geoSrc.fVertexSrc = kNone_GeometrySrcType; 315} 316 317void GrDrawTarget::resetIndexSource() { 318 this->releasePreviousIndexSource(); 319 GeometrySrcState& geoSrc = fGeoSrcStateStack.back(); 320 geoSrc.fIndexSrc = kNone_GeometrySrcType; 321} 322 323void GrDrawTarget::pushGeometrySource() { 324 this->geometrySourceWillPush(); 325 GeometrySrcState& newState = fGeoSrcStateStack.push_back(); 326 newState.fIndexSrc = kNone_GeometrySrcType; 327 newState.fVertexSrc = kNone_GeometrySrcType; 328#ifdef SK_DEBUG 329 newState.fVertexCount = ~0; 330 newState.fVertexBuffer = (GrVertexBuffer*)~0; 331 newState.fIndexCount = ~0; 332 newState.fIndexBuffer = (GrIndexBuffer*)~0; 333#endif 334} 335 336void GrDrawTarget::popGeometrySource() { 337 // if popping last element then pops are unbalanced with pushes 338 SkASSERT(fGeoSrcStateStack.count() > 1); 339 340 this->geometrySourceWillPop(fGeoSrcStateStack.fromBack(1)); 341 this->releasePreviousVertexSource(); 342 this->releasePreviousIndexSource(); 343 fGeoSrcStateStack.pop_back(); 344} 345 346//////////////////////////////////////////////////////////////////////////////// 347 348bool GrDrawTarget::checkDraw(GrPrimitiveType type, int startVertex, 349 int startIndex, int vertexCount, 350 int indexCount) const { 351 const GrDrawState& drawState = this->getDrawState(); 352#ifdef SK_DEBUG 353 const GeometrySrcState& geoSrc = fGeoSrcStateStack.back(); 354 int maxVertex = startVertex + vertexCount; 355 int maxValidVertex; 356 switch (geoSrc.fVertexSrc) { 357 case kNone_GeometrySrcType: 358 GrCrash("Attempting to draw without vertex src."); 359 case kReserved_GeometrySrcType: // fallthrough 360 case kArray_GeometrySrcType: 361 maxValidVertex = geoSrc.fVertexCount; 362 break; 363 case kBuffer_GeometrySrcType: 364 maxValidVertex = static_cast<int>(geoSrc.fVertexBuffer->sizeInBytes() / geoSrc.fVertexSize); 365 break; 366 } 367 if (maxVertex > maxValidVertex) { 368 GrCrash("Drawing outside valid vertex range."); 369 } 370 if (indexCount > 0) { 371 int maxIndex = startIndex + indexCount; 372 int maxValidIndex; 373 switch (geoSrc.fIndexSrc) { 374 case kNone_GeometrySrcType: 375 GrCrash("Attempting to draw indexed geom without index src."); 376 case kReserved_GeometrySrcType: // fallthrough 377 case kArray_GeometrySrcType: 378 maxValidIndex = geoSrc.fIndexCount; 379 break; 380 case kBuffer_GeometrySrcType: 381 maxValidIndex = static_cast<int>(geoSrc.fIndexBuffer->sizeInBytes() / sizeof(uint16_t)); 382 break; 383 } 384 if (maxIndex > maxValidIndex) { 385 GrCrash("Index reads outside valid index range."); 386 } 387 } 388 389 SkASSERT(NULL != drawState.getRenderTarget()); 390 391 for (int s = 0; s < drawState.numColorStages(); ++s) { 392 const GrEffectRef& effect = *drawState.getColorStage(s).getEffect(); 393 int numTextures = effect->numTextures(); 394 for (int t = 0; t < numTextures; ++t) { 395 GrTexture* texture = effect->texture(t); 396 SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget()); 397 } 398 } 399 for (int s = 0; s < drawState.numCoverageStages(); ++s) { 400 const GrEffectRef& effect = *drawState.getCoverageStage(s).getEffect(); 401 int numTextures = effect->numTextures(); 402 for (int t = 0; t < numTextures; ++t) { 403 GrTexture* texture = effect->texture(t); 404 SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget()); 405 } 406 } 407 408 SkASSERT(drawState.validateVertexAttribs()); 409#endif 410 if (NULL == drawState.getRenderTarget()) { 411 return false; 412 } 413 return true; 414} 415 416bool GrDrawTarget::setupDstReadIfNecessary(GrDeviceCoordTexture* dstCopy, const SkRect* drawBounds) { 417 if (this->caps()->dstReadInShaderSupport() || !this->getDrawState().willEffectReadDstColor()) { 418 return true; 419 } 420 GrRenderTarget* rt = this->drawState()->getRenderTarget(); 421 SkIRect copyRect; 422 const GrClipData* clip = this->getClip(); 423 clip->getConservativeBounds(rt, ©Rect); 424 425 if (NULL != drawBounds) { 426 SkIRect drawIBounds; 427 drawBounds->roundOut(&drawIBounds); 428 if (!copyRect.intersect(drawIBounds)) { 429#ifdef SK_DEBUG 430 GrPrintf("Missed an early reject. Bailing on draw from setupDstReadIfNecessary.\n"); 431#endif 432 return false; 433 } 434 } else { 435#ifdef SK_DEBUG 436 //GrPrintf("No dev bounds when dst copy is made.\n"); 437#endif 438 } 439 440 // MSAA consideration: When there is support for reading MSAA samples in the shader we could 441 // have per-sample dst values by making the copy multisampled. 442 GrTextureDesc desc; 443 this->initCopySurfaceDstDesc(rt, &desc); 444 desc.fWidth = copyRect.width(); 445 desc.fHeight = copyRect.height(); 446 447 GrAutoScratchTexture ast(fContext, desc, GrContext::kApprox_ScratchTexMatch); 448 449 if (NULL == ast.texture()) { 450 GrPrintf("Failed to create temporary copy of destination texture.\n"); 451 return false; 452 } 453 SkIPoint dstPoint = {0, 0}; 454 if (this->copySurface(ast.texture(), rt, copyRect, dstPoint)) { 455 dstCopy->setTexture(ast.texture()); 456 dstCopy->setOffset(copyRect.fLeft, copyRect.fTop); 457 return true; 458 } else { 459 return false; 460 } 461} 462 463void GrDrawTarget::drawIndexed(GrPrimitiveType type, 464 int startVertex, 465 int startIndex, 466 int vertexCount, 467 int indexCount, 468 const SkRect* devBounds) { 469 if (indexCount > 0 && this->checkDraw(type, startVertex, startIndex, vertexCount, indexCount)) { 470 DrawInfo info; 471 info.fPrimitiveType = type; 472 info.fStartVertex = startVertex; 473 info.fStartIndex = startIndex; 474 info.fVertexCount = vertexCount; 475 info.fIndexCount = indexCount; 476 477 info.fInstanceCount = 0; 478 info.fVerticesPerInstance = 0; 479 info.fIndicesPerInstance = 0; 480 481 if (NULL != devBounds) { 482 info.setDevBounds(*devBounds); 483 } 484 // TODO: We should continue with incorrect blending. 485 if (!this->setupDstReadIfNecessary(&info)) { 486 return; 487 } 488 this->onDraw(info); 489 } 490} 491 492void GrDrawTarget::drawNonIndexed(GrPrimitiveType type, 493 int startVertex, 494 int vertexCount, 495 const SkRect* devBounds) { 496 if (vertexCount > 0 && this->checkDraw(type, startVertex, -1, vertexCount, -1)) { 497 DrawInfo info; 498 info.fPrimitiveType = type; 499 info.fStartVertex = startVertex; 500 info.fStartIndex = 0; 501 info.fVertexCount = vertexCount; 502 info.fIndexCount = 0; 503 504 info.fInstanceCount = 0; 505 info.fVerticesPerInstance = 0; 506 info.fIndicesPerInstance = 0; 507 508 if (NULL != devBounds) { 509 info.setDevBounds(*devBounds); 510 } 511 // TODO: We should continue with incorrect blending. 512 if (!this->setupDstReadIfNecessary(&info)) { 513 return; 514 } 515 this->onDraw(info); 516 } 517} 518 519void GrDrawTarget::stencilPath(const GrPath* path, SkPath::FillType fill) { 520 // TODO: extract portions of checkDraw that are relevant to path stenciling. 521 SkASSERT(NULL != path); 522 SkASSERT(this->caps()->pathRenderingSupport()); 523 SkASSERT(!SkPath::IsInverseFillType(fill)); 524 this->onStencilPath(path, fill); 525} 526 527void GrDrawTarget::drawPath(const GrPath* path, SkPath::FillType fill) { 528 // TODO: extract portions of checkDraw that are relevant to path rendering. 529 SkASSERT(NULL != path); 530 SkASSERT(this->caps()->pathRenderingSupport()); 531 const GrDrawState* drawState = &getDrawState(); 532 533 SkRect devBounds; 534 if (SkPath::IsInverseFillType(fill)) { 535 devBounds = SkRect::MakeWH(SkIntToScalar(drawState->getRenderTarget()->width()), 536 SkIntToScalar(drawState->getRenderTarget()->height())); 537 } else { 538 devBounds = path->getBounds(); 539 } 540 SkMatrix viewM = drawState->getViewMatrix(); 541 viewM.mapRect(&devBounds); 542 543 GrDeviceCoordTexture dstCopy; 544 if (!this->setupDstReadIfNecessary(&dstCopy, &devBounds)) { 545 return; 546 } 547 548 this->onDrawPath(path, fill, dstCopy.texture() ? &dstCopy : NULL); 549} 550 551void GrDrawTarget::drawPaths(size_t pathCount, const GrPath** paths, 552 const SkMatrix* transforms, 553 SkPath::FillType fill, SkStrokeRec::Style stroke) { 554 SkASSERT(pathCount > 0); 555 SkASSERT(NULL != paths); 556 SkASSERT(NULL != paths[0]); 557 SkASSERT(this->caps()->pathRenderingSupport()); 558 SkASSERT(!SkPath::IsInverseFillType(fill)); 559 560 const GrDrawState* drawState = &getDrawState(); 561 562 SkRect devBounds; 563 for (size_t i = 0; i < pathCount; ++i) { 564 SkRect mappedPathBounds; 565 transforms[i].mapRect(&mappedPathBounds, paths[i]->getBounds()); 566 devBounds.join(mappedPathBounds); 567 } 568 569 SkMatrix viewM = drawState->getViewMatrix(); 570 viewM.mapRect(&devBounds); 571 572 GrDeviceCoordTexture dstCopy; 573 if (!this->setupDstReadIfNecessary(&dstCopy, &devBounds)) { 574 return; 575 } 576 577 this->onDrawPaths(pathCount, paths, transforms, fill, stroke, 578 dstCopy.texture() ? &dstCopy : NULL); 579} 580 581void GrDrawTarget::addGpuTraceMarker(GrGpuTraceMarker* marker) { 582 if (this->caps()->gpuTracingSupport()) { 583 SkASSERT(fGpuTraceMarkerCount >= 0); 584 this->fActiveTraceMarkers.add(*marker); 585 this->didAddGpuTraceMarker(); 586 ++fGpuTraceMarkerCount; 587 } 588} 589 590void GrDrawTarget::removeGpuTraceMarker(GrGpuTraceMarker* marker) { 591 if (this->caps()->gpuTracingSupport()) { 592 SkASSERT(fGpuTraceMarkerCount >= 1); 593 this->fActiveTraceMarkers.remove(*marker); 594 this->didRemoveGpuTraceMarker(); 595 --fGpuTraceMarkerCount; 596 } 597} 598 599//////////////////////////////////////////////////////////////////////////////// 600 601bool GrDrawTarget::willUseHWAALines() const { 602 // There is a conflict between using smooth lines and our use of premultiplied alpha. Smooth 603 // lines tweak the incoming alpha value but not in a premul-alpha way. So we only use them when 604 // our alpha is 0xff and tweaking the color for partial coverage is OK 605 if (!this->caps()->hwAALineSupport() || 606 !this->getDrawState().isHWAntialiasState()) { 607 return false; 608 } 609 GrDrawState::BlendOptFlags opts = this->getDrawState().getBlendOpts(); 610 return (GrDrawState::kDisableBlend_BlendOptFlag & opts) && 611 (GrDrawState::kCoverageAsAlpha_BlendOptFlag & opts); 612} 613 614bool GrDrawTarget::canApplyCoverage() const { 615 // we can correctly apply coverage if a) we have dual source blending 616 // or b) one of our blend optimizations applies. 617 return this->caps()->dualSourceBlendingSupport() || 618 GrDrawState::kNone_BlendOpt != this->getDrawState().getBlendOpts(true); 619} 620 621//////////////////////////////////////////////////////////////////////////////// 622 623void GrDrawTarget::drawIndexedInstances(GrPrimitiveType type, 624 int instanceCount, 625 int verticesPerInstance, 626 int indicesPerInstance, 627 const SkRect* devBounds) { 628 if (!verticesPerInstance || !indicesPerInstance) { 629 return; 630 } 631 632 int maxInstancesPerDraw = this->indexCountInCurrentSource() / indicesPerInstance; 633 if (!maxInstancesPerDraw) { 634 return; 635 } 636 637 DrawInfo info; 638 info.fPrimitiveType = type; 639 info.fStartIndex = 0; 640 info.fStartVertex = 0; 641 info.fIndicesPerInstance = indicesPerInstance; 642 info.fVerticesPerInstance = verticesPerInstance; 643 644 // Set the same bounds for all the draws. 645 if (NULL != devBounds) { 646 info.setDevBounds(*devBounds); 647 } 648 // TODO: We should continue with incorrect blending. 649 if (!this->setupDstReadIfNecessary(&info)) { 650 return; 651 } 652 653 while (instanceCount) { 654 info.fInstanceCount = GrMin(instanceCount, maxInstancesPerDraw); 655 info.fVertexCount = info.fInstanceCount * verticesPerInstance; 656 info.fIndexCount = info.fInstanceCount * indicesPerInstance; 657 658 if (this->checkDraw(type, 659 info.fStartVertex, 660 info.fStartIndex, 661 info.fVertexCount, 662 info.fIndexCount)) { 663 this->onDraw(info); 664 } 665 info.fStartVertex += info.fVertexCount; 666 instanceCount -= info.fInstanceCount; 667 } 668} 669 670//////////////////////////////////////////////////////////////////////////////// 671 672namespace { 673 674// position + (optional) texture coord 675extern const GrVertexAttrib gBWRectPosUVAttribs[] = { 676 {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding}, 677 {kVec2f_GrVertexAttribType, sizeof(GrPoint), kLocalCoord_GrVertexAttribBinding} 678}; 679 680void set_vertex_attributes(GrDrawState* drawState, bool hasUVs) { 681 if (hasUVs) { 682 drawState->setVertexAttribs<gBWRectPosUVAttribs>(2); 683 } else { 684 drawState->setVertexAttribs<gBWRectPosUVAttribs>(1); 685 } 686} 687 688}; 689 690void GrDrawTarget::onDrawRect(const SkRect& rect, 691 const SkMatrix* matrix, 692 const SkRect* localRect, 693 const SkMatrix* localMatrix) { 694 695 GrDrawState::AutoViewMatrixRestore avmr; 696 if (NULL != matrix) { 697 avmr.set(this->drawState(), *matrix); 698 } 699 700 set_vertex_attributes(this->drawState(), NULL != localRect); 701 702 AutoReleaseGeometry geo(this, 4, 0); 703 if (!geo.succeeded()) { 704 GrPrintf("Failed to get space for vertices!\n"); 705 return; 706 } 707 708 size_t vsize = this->drawState()->getVertexSize(); 709 geo.positions()->setRectFan(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, vsize); 710 if (NULL != localRect) { 711 GrPoint* coords = GrTCast<GrPoint*>(GrTCast<intptr_t>(geo.vertices()) + 712 sizeof(GrPoint)); 713 coords->setRectFan(localRect->fLeft, localRect->fTop, 714 localRect->fRight, localRect->fBottom, 715 vsize); 716 if (NULL != localMatrix) { 717 localMatrix->mapPointsWithStride(coords, vsize, 4); 718 } 719 } 720 SkRect bounds; 721 this->getDrawState().getViewMatrix().mapRect(&bounds, rect); 722 723 this->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4, &bounds); 724} 725 726void GrDrawTarget::clipWillBeSet(const GrClipData* clipData) { 727} 728 729//////////////////////////////////////////////////////////////////////////////// 730 731GrDrawTarget::AutoStateRestore::AutoStateRestore() { 732 fDrawTarget = NULL; 733} 734 735GrDrawTarget::AutoStateRestore::AutoStateRestore(GrDrawTarget* target, 736 ASRInit init, 737 const SkMatrix* vm) { 738 fDrawTarget = NULL; 739 this->set(target, init, vm); 740} 741 742GrDrawTarget::AutoStateRestore::~AutoStateRestore() { 743 if (NULL != fDrawTarget) { 744 fDrawTarget->setDrawState(fSavedState); 745 fSavedState->unref(); 746 } 747} 748 749void GrDrawTarget::AutoStateRestore::set(GrDrawTarget* target, ASRInit init, const SkMatrix* vm) { 750 SkASSERT(NULL == fDrawTarget); 751 fDrawTarget = target; 752 fSavedState = target->drawState(); 753 SkASSERT(fSavedState); 754 fSavedState->ref(); 755 if (kReset_ASRInit == init) { 756 if (NULL == vm) { 757 // calls the default cons 758 fTempState.init(); 759 } else { 760 SkNEW_IN_TLAZY(&fTempState, GrDrawState, (*vm)); 761 } 762 } else { 763 SkASSERT(kPreserve_ASRInit == init); 764 if (NULL == vm) { 765 fTempState.set(*fSavedState); 766 } else { 767 SkNEW_IN_TLAZY(&fTempState, GrDrawState, (*fSavedState, *vm)); 768 } 769 } 770 target->setDrawState(fTempState.get()); 771} 772 773bool GrDrawTarget::AutoStateRestore::setIdentity(GrDrawTarget* target, ASRInit init) { 774 SkASSERT(NULL == fDrawTarget); 775 fDrawTarget = target; 776 fSavedState = target->drawState(); 777 SkASSERT(fSavedState); 778 fSavedState->ref(); 779 if (kReset_ASRInit == init) { 780 // calls the default cons 781 fTempState.init(); 782 } else { 783 SkASSERT(kPreserve_ASRInit == init); 784 // calls the copy cons 785 fTempState.set(*fSavedState); 786 if (!fTempState.get()->setIdentityViewMatrix()) { 787 // let go of any resources held by the temp 788 fTempState.get()->reset(); 789 fDrawTarget = NULL; 790 fSavedState->unref(); 791 fSavedState = NULL; 792 return false; 793 } 794 } 795 target->setDrawState(fTempState.get()); 796 return true; 797} 798 799//////////////////////////////////////////////////////////////////////////////// 800 801GrDrawTarget::AutoReleaseGeometry::AutoReleaseGeometry( 802 GrDrawTarget* target, 803 int vertexCount, 804 int indexCount) { 805 fTarget = NULL; 806 this->set(target, vertexCount, indexCount); 807} 808 809GrDrawTarget::AutoReleaseGeometry::AutoReleaseGeometry() { 810 fTarget = NULL; 811} 812 813GrDrawTarget::AutoReleaseGeometry::~AutoReleaseGeometry() { 814 this->reset(); 815} 816 817bool GrDrawTarget::AutoReleaseGeometry::set(GrDrawTarget* target, 818 int vertexCount, 819 int indexCount) { 820 this->reset(); 821 fTarget = target; 822 bool success = true; 823 if (NULL != fTarget) { 824 fTarget = target; 825 success = target->reserveVertexAndIndexSpace(vertexCount, 826 indexCount, 827 &fVertices, 828 &fIndices); 829 if (!success) { 830 fTarget = NULL; 831 this->reset(); 832 } 833 } 834 SkASSERT(success == (NULL != fTarget)); 835 return success; 836} 837 838void GrDrawTarget::AutoReleaseGeometry::reset() { 839 if (NULL != fTarget) { 840 if (NULL != fVertices) { 841 fTarget->resetVertexSource(); 842 } 843 if (NULL != fIndices) { 844 fTarget->resetIndexSource(); 845 } 846 fTarget = NULL; 847 } 848 fVertices = NULL; 849 fIndices = NULL; 850} 851 852GrDrawTarget::AutoClipRestore::AutoClipRestore(GrDrawTarget* target, const SkIRect& newClip) { 853 fTarget = target; 854 fClip = fTarget->getClip(); 855 fStack.init(); 856 fStack.get()->clipDevRect(newClip, SkRegion::kReplace_Op); 857 fReplacementClip.fClipStack = fStack.get(); 858 target->setClip(&fReplacementClip); 859} 860 861namespace { 862// returns true if the read/written rect intersects the src/dst and false if not. 863bool clip_srcrect_and_dstpoint(const GrSurface* dst, 864 const GrSurface* src, 865 const SkIRect& srcRect, 866 const SkIPoint& dstPoint, 867 SkIRect* clippedSrcRect, 868 SkIPoint* clippedDstPoint) { 869 *clippedSrcRect = srcRect; 870 *clippedDstPoint = dstPoint; 871 872 // clip the left edge to src and dst bounds, adjusting dstPoint if necessary 873 if (clippedSrcRect->fLeft < 0) { 874 clippedDstPoint->fX -= clippedSrcRect->fLeft; 875 clippedSrcRect->fLeft = 0; 876 } 877 if (clippedDstPoint->fX < 0) { 878 clippedSrcRect->fLeft -= clippedDstPoint->fX; 879 clippedDstPoint->fX = 0; 880 } 881 882 // clip the top edge to src and dst bounds, adjusting dstPoint if necessary 883 if (clippedSrcRect->fTop < 0) { 884 clippedDstPoint->fY -= clippedSrcRect->fTop; 885 clippedSrcRect->fTop = 0; 886 } 887 if (clippedDstPoint->fY < 0) { 888 clippedSrcRect->fTop -= clippedDstPoint->fY; 889 clippedDstPoint->fY = 0; 890 } 891 892 // clip the right edge to the src and dst bounds. 893 if (clippedSrcRect->fRight > src->width()) { 894 clippedSrcRect->fRight = src->width(); 895 } 896 if (clippedDstPoint->fX + clippedSrcRect->width() > dst->width()) { 897 clippedSrcRect->fRight = clippedSrcRect->fLeft + dst->width() - clippedDstPoint->fX; 898 } 899 900 // clip the bottom edge to the src and dst bounds. 901 if (clippedSrcRect->fBottom > src->height()) { 902 clippedSrcRect->fBottom = src->height(); 903 } 904 if (clippedDstPoint->fY + clippedSrcRect->height() > dst->height()) { 905 clippedSrcRect->fBottom = clippedSrcRect->fTop + dst->height() - clippedDstPoint->fY; 906 } 907 908 // The above clipping steps may have inverted the rect if it didn't intersect either the src or 909 // dst bounds. 910 return !clippedSrcRect->isEmpty(); 911} 912} 913 914bool GrDrawTarget::copySurface(GrSurface* dst, 915 GrSurface* src, 916 const SkIRect& srcRect, 917 const SkIPoint& dstPoint) { 918 SkASSERT(NULL != dst); 919 SkASSERT(NULL != src); 920 921 SkIRect clippedSrcRect; 922 SkIPoint clippedDstPoint; 923 // If the rect is outside the src or dst then we've already succeeded. 924 if (!clip_srcrect_and_dstpoint(dst, 925 src, 926 srcRect, 927 dstPoint, 928 &clippedSrcRect, 929 &clippedDstPoint)) { 930 SkASSERT(this->canCopySurface(dst, src, srcRect, dstPoint)); 931 return true; 932 } 933 934 bool result = this->onCopySurface(dst, src, clippedSrcRect, clippedDstPoint); 935 SkASSERT(result == this->canCopySurface(dst, src, clippedSrcRect, clippedDstPoint)); 936 return result; 937} 938 939bool GrDrawTarget::canCopySurface(GrSurface* dst, 940 GrSurface* src, 941 const SkIRect& srcRect, 942 const SkIPoint& dstPoint) { 943 SkASSERT(NULL != dst); 944 SkASSERT(NULL != src); 945 946 SkIRect clippedSrcRect; 947 SkIPoint clippedDstPoint; 948 // If the rect is outside the src or dst then we're guaranteed success 949 if (!clip_srcrect_and_dstpoint(dst, 950 src, 951 srcRect, 952 dstPoint, 953 &clippedSrcRect, 954 &clippedDstPoint)) { 955 return true; 956 } 957 return this->onCanCopySurface(dst, src, clippedSrcRect, clippedDstPoint); 958} 959 960bool GrDrawTarget::onCanCopySurface(GrSurface* dst, 961 GrSurface* src, 962 const SkIRect& srcRect, 963 const SkIPoint& dstPoint) { 964 // Check that the read/write rects are contained within the src/dst bounds. 965 SkASSERT(!srcRect.isEmpty()); 966 SkASSERT(SkIRect::MakeWH(src->width(), src->height()).contains(srcRect)); 967 SkASSERT(dstPoint.fX >= 0 && dstPoint.fY >= 0); 968 SkASSERT(dstPoint.fX + srcRect.width() <= dst->width() && 969 dstPoint.fY + srcRect.height() <= dst->height()); 970 971 return !dst->isSameAs(src) && NULL != dst->asRenderTarget() && NULL != src->asTexture(); 972} 973 974bool GrDrawTarget::onCopySurface(GrSurface* dst, 975 GrSurface* src, 976 const SkIRect& srcRect, 977 const SkIPoint& dstPoint) { 978 if (!GrDrawTarget::onCanCopySurface(dst, src, srcRect, dstPoint)) { 979 return false; 980 } 981 982 GrRenderTarget* rt = dst->asRenderTarget(); 983 GrTexture* tex = src->asTexture(); 984 985 GrDrawTarget::AutoStateRestore asr(this, kReset_ASRInit); 986 this->drawState()->setRenderTarget(rt); 987 SkMatrix matrix; 988 matrix.setTranslate(SkIntToScalar(srcRect.fLeft - dstPoint.fX), 989 SkIntToScalar(srcRect.fTop - dstPoint.fY)); 990 matrix.postIDiv(tex->width(), tex->height()); 991 this->drawState()->addColorTextureEffect(tex, matrix); 992 SkIRect dstRect = SkIRect::MakeXYWH(dstPoint.fX, 993 dstPoint.fY, 994 srcRect.width(), 995 srcRect.height()); 996 this->drawSimpleRect(dstRect); 997 return true; 998} 999 1000void GrDrawTarget::initCopySurfaceDstDesc(const GrSurface* src, GrTextureDesc* desc) { 1001 // Make the dst of the copy be a render target because the default copySurface draws to the dst. 1002 desc->fOrigin = kDefault_GrSurfaceOrigin; 1003 desc->fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit; 1004 desc->fConfig = src->config(); 1005} 1006 1007/////////////////////////////////////////////////////////////////////////////// 1008 1009void GrDrawTargetCaps::reset() { 1010 f8BitPaletteSupport = false; 1011 fMipMapSupport = false; 1012 fNPOTTextureTileSupport = false; 1013 fTwoSidedStencilSupport = false; 1014 fStencilWrapOpsSupport = false; 1015 fHWAALineSupport = false; 1016 fShaderDerivativeSupport = false; 1017 fGeometryShaderSupport = false; 1018 fDualSourceBlendingSupport = false; 1019 fBufferLockSupport = false; 1020 fPathRenderingSupport = false; 1021 fDstReadInShaderSupport = false; 1022 fReuseScratchTextures = true; 1023 fGpuTracingSupport = false; 1024 1025 fMaxRenderTargetSize = 0; 1026 fMaxTextureSize = 0; 1027 fMaxSampleCount = 0; 1028 1029 memset(fConfigRenderSupport, 0, sizeof(fConfigRenderSupport)); 1030} 1031 1032GrDrawTargetCaps& GrDrawTargetCaps::operator=(const GrDrawTargetCaps& other) { 1033 f8BitPaletteSupport = other.f8BitPaletteSupport; 1034 fMipMapSupport = other.fMipMapSupport; 1035 fNPOTTextureTileSupport = other.fNPOTTextureTileSupport; 1036 fTwoSidedStencilSupport = other.fTwoSidedStencilSupport; 1037 fStencilWrapOpsSupport = other.fStencilWrapOpsSupport; 1038 fHWAALineSupport = other.fHWAALineSupport; 1039 fShaderDerivativeSupport = other.fShaderDerivativeSupport; 1040 fGeometryShaderSupport = other.fGeometryShaderSupport; 1041 fDualSourceBlendingSupport = other.fDualSourceBlendingSupport; 1042 fBufferLockSupport = other.fBufferLockSupport; 1043 fPathRenderingSupport = other.fPathRenderingSupport; 1044 fDstReadInShaderSupport = other.fDstReadInShaderSupport; 1045 fReuseScratchTextures = other.fReuseScratchTextures; 1046 fGpuTracingSupport = other.fGpuTracingSupport; 1047 1048 fMaxRenderTargetSize = other.fMaxRenderTargetSize; 1049 fMaxTextureSize = other.fMaxTextureSize; 1050 fMaxSampleCount = other.fMaxSampleCount; 1051 1052 memcpy(fConfigRenderSupport, other.fConfigRenderSupport, sizeof(fConfigRenderSupport)); 1053 1054 return *this; 1055} 1056 1057SkString GrDrawTargetCaps::dump() const { 1058 SkString r; 1059 static const char* gNY[] = {"NO", "YES"}; 1060 r.appendf("8 Bit Palette Support : %s\n", gNY[f8BitPaletteSupport]); 1061 r.appendf("MIP Map Support : %s\n", gNY[fMipMapSupport]); 1062 r.appendf("NPOT Texture Tile Support : %s\n", gNY[fNPOTTextureTileSupport]); 1063 r.appendf("Two Sided Stencil Support : %s\n", gNY[fTwoSidedStencilSupport]); 1064 r.appendf("Stencil Wrap Ops Support : %s\n", gNY[fStencilWrapOpsSupport]); 1065 r.appendf("HW AA Lines Support : %s\n", gNY[fHWAALineSupport]); 1066 r.appendf("Shader Derivative Support : %s\n", gNY[fShaderDerivativeSupport]); 1067 r.appendf("Geometry Shader Support : %s\n", gNY[fGeometryShaderSupport]); 1068 r.appendf("Dual Source Blending Support: %s\n", gNY[fDualSourceBlendingSupport]); 1069 r.appendf("Buffer Lock Support : %s\n", gNY[fBufferLockSupport]); 1070 r.appendf("Path Rendering Support : %s\n", gNY[fPathRenderingSupport]); 1071 r.appendf("Dst Read In Shader Support : %s\n", gNY[fDstReadInShaderSupport]); 1072 r.appendf("Reuse Scratch Textures : %s\n", gNY[fReuseScratchTextures]); 1073 r.appendf("Gpu Tracing Support : %s\n", gNY[fGpuTracingSupport]); 1074 r.appendf("Max Texture Size : %d\n", fMaxTextureSize); 1075 r.appendf("Max Render Target Size : %d\n", fMaxRenderTargetSize); 1076 r.appendf("Max Sample Count : %d\n", fMaxSampleCount); 1077 1078 static const char* kConfigNames[] = { 1079 "Unknown", // kUnknown_GrPixelConfig 1080 "Alpha8", // kAlpha_8_GrPixelConfig, 1081 "Index8", // kIndex_8_GrPixelConfig, 1082 "RGB565", // kRGB_565_GrPixelConfig, 1083 "RGBA444", // kRGBA_4444_GrPixelConfig, 1084 "RGBA8888", // kRGBA_8888_GrPixelConfig, 1085 "BGRA8888", // kBGRA_8888_GrPixelConfig, 1086 }; 1087 GR_STATIC_ASSERT(0 == kUnknown_GrPixelConfig); 1088 GR_STATIC_ASSERT(1 == kAlpha_8_GrPixelConfig); 1089 GR_STATIC_ASSERT(2 == kIndex_8_GrPixelConfig); 1090 GR_STATIC_ASSERT(3 == kRGB_565_GrPixelConfig); 1091 GR_STATIC_ASSERT(4 == kRGBA_4444_GrPixelConfig); 1092 GR_STATIC_ASSERT(5 == kRGBA_8888_GrPixelConfig); 1093 GR_STATIC_ASSERT(6 == kBGRA_8888_GrPixelConfig); 1094 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kConfigNames) == kGrPixelConfigCnt); 1095 1096 SkASSERT(!fConfigRenderSupport[kUnknown_GrPixelConfig][0]); 1097 SkASSERT(!fConfigRenderSupport[kUnknown_GrPixelConfig][1]); 1098 for (size_t i = 0; i < SK_ARRAY_COUNT(kConfigNames); ++i) { 1099 if (i != kUnknown_GrPixelConfig) { 1100 r.appendf("%s is renderable: %s, with MSAA: %s\n", 1101 kConfigNames[i], 1102 gNY[fConfigRenderSupport[i][0]], 1103 gNY[fConfigRenderSupport[i][1]]); 1104 } 1105 } 1106 return r; 1107} 1108