DisplayListOp.h revision b565df13a9e5c7b1d7d93bdfa4a793752d66d3cc
1/* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef ANDROID_HWUI_DISPLAY_OPERATION_H 18#define ANDROID_HWUI_DISPLAY_OPERATION_H 19 20#include "OpenGLRenderer.h" 21#include "AssetAtlas.h" 22#include "DeferredDisplayList.h" 23#include "DisplayListCanvas.h" 24#include "GammaFontRenderer.h" 25#include "Patch.h" 26#include "RenderNode.h" 27#include "renderstate/RenderState.h" 28#include "UvMapper.h" 29#include "utils/LinearAllocator.h" 30#include "utils/PaintUtils.h" 31 32#include <algorithm> 33 34#include <SkColor.h> 35#include <SkPath.h> 36#include <SkPathOps.h> 37#include <SkXfermode.h> 38 39#include <private/hwui/DrawGlInfo.h> 40 41// Use OP_LOG for logging with arglist, OP_LOGS if just printing char* 42#define OP_LOGS(s) OP_LOG("%s", (s)) 43#define OP_LOG(s, ...) ALOGD( "%*s" s, level * 2, "", __VA_ARGS__ ) 44 45namespace android { 46namespace uirenderer { 47 48/** 49 * Structure for storing canvas operations when they are recorded into a DisplayList, so that they 50 * may be replayed to an OpenGLRenderer. 51 * 52 * To avoid individual memory allocations, DisplayListOps may only be allocated into a 53 * LinearAllocator's managed memory buffers. Each pointer held by a DisplayListOp is either a 54 * pointer into memory also allocated in the LinearAllocator (mostly for text and float buffers) or 55 * references a externally refcounted object (Sk... and Skia... objects). ~DisplayListOp() is 56 * never called as LinearAllocators are simply discarded, so no memory management should be done in 57 * this class. 58 */ 59class DisplayListOp { 60public: 61 // These objects should always be allocated with a LinearAllocator, and never destroyed/deleted. 62 // standard new() intentionally not implemented, and delete/deconstructor should never be used. 63 virtual ~DisplayListOp() { LOG_ALWAYS_FATAL("Destructor not supported"); } 64 static void operator delete(void* ptr) { LOG_ALWAYS_FATAL("delete not supported"); } 65 static void* operator new(size_t size) = delete; /** PURPOSELY OMITTED **/ 66 static void* operator new(size_t size, LinearAllocator& allocator) { 67 return allocator.alloc(size); 68 } 69 70 enum OpLogFlag { 71 kOpLogFlag_Recurse = 0x1, 72 kOpLogFlag_JSON = 0x2 // TODO: add? 73 }; 74 75 virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level, 76 bool useQuickReject) = 0; 77 78 virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level, 79 bool useQuickReject) = 0; 80 81 virtual void output(int level, uint32_t logFlags = 0) const = 0; 82 83 // NOTE: it would be nice to declare constants and overriding the implementation in each op to 84 // point at the constants, but that seems to require a .cpp file 85 virtual const char* name() = 0; 86}; 87 88class StateOp : public DisplayListOp { 89public: 90 virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level, 91 bool useQuickReject) override { 92 // default behavior only affects immediate, deferrable state, issue directly to renderer 93 applyState(deferStruct.mRenderer, saveCount); 94 } 95 96 /** 97 * State operations are applied directly to the renderer, but can cause the deferred drawing op 98 * list to flush 99 */ 100 virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level, 101 bool useQuickReject) override { 102 applyState(replayStruct.mRenderer, saveCount); 103 } 104 105 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const = 0; 106}; 107 108class DrawOp : public DisplayListOp { 109friend class MergingDrawBatch; 110public: 111 DrawOp(const SkPaint* paint) 112 : mPaint(paint), mQuickRejected(false) {} 113 114 virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level, 115 bool useQuickReject) override { 116 if (mQuickRejected && CC_LIKELY(useQuickReject)) { 117 return; 118 } 119 120 deferStruct.mDeferredList.addDrawOp(deferStruct.mRenderer, this); 121 } 122 123 virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level, 124 bool useQuickReject) override { 125 if (mQuickRejected && CC_LIKELY(useQuickReject)) { 126 return; 127 } 128 129 applyDraw(replayStruct.mRenderer, replayStruct.mDirty); 130 } 131 132 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) = 0; 133 134 /** 135 * Draw multiple instances of an operation, must be overidden for operations that merge 136 * 137 * Currently guarantees certain similarities between ops (see MergingDrawBatch::canMergeWith), 138 * and pure translation transformations. Other guarantees of similarity should be enforced by 139 * reducing which operations are tagged as mergeable. 140 */ 141 virtual void multiDraw(OpenGLRenderer& renderer, Rect& dirty, 142 const std::vector<OpStatePair>& ops, const Rect& bounds) { 143 for (unsigned int i = 0; i < ops.size(); i++) { 144 renderer.restoreDisplayState(*(ops[i].state), true); 145 ops[i].op->applyDraw(renderer, dirty); 146 } 147 } 148 149 /** 150 * When this method is invoked the state field is initialized to have the 151 * final rendering state. We can thus use it to process data as it will be 152 * used at draw time. 153 * 154 * Additionally, this method allows subclasses to provide defer-time preferences for batching 155 * and merging. 156 * 157 * if a subclass can set deferInfo.mergeable to true, it should implement multiDraw() 158 */ 159 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 160 const DeferredDisplayState& state) {} 161 162 /** 163 * Query the conservative, local bounds (unmapped) bounds of the op. 164 * 165 * returns true if bounds exist 166 */ 167 virtual bool getLocalBounds(Rect& localBounds) { 168 return false; 169 } 170 171 // TODO: better refine localbounds usage 172 void setQuickRejected(bool quickRejected) { mQuickRejected = quickRejected; } 173 bool getQuickRejected() { return mQuickRejected; } 174 175 virtual bool hasTextShadow() const { 176 return false; 177 } 178 179 inline float strokeWidthOutset() { 180 // since anything AA stroke with less than 1.0 pixel width is drawn with an alpha-reduced 181 // 1.0 stroke, treat 1.0 as minimum. 182 183 // TODO: it would be nice if this could take scale into account, but scale isn't stable 184 // since higher levels of the view hierarchy can change scale out from underneath it. 185 return std::max(mPaint->getStrokeWidth(), 1.0f) * 0.5f; 186 } 187 188protected: 189 // Helper method for determining op opaqueness. Assumes op fills its bounds in local 190 // coordinates, and that paint's alpha is used 191 inline bool isOpaqueOverBounds(const DeferredDisplayState& state) { 192 // ensure that local bounds cover mapped bounds 193 if (!state.mMatrix.isSimple()) return false; 194 195 if (state.mRoundRectClipState) return false; 196 197 // check state/paint for transparency 198 if (mPaint) { 199 if (mPaint->getAlpha() != 0xFF) { 200 return false; 201 } 202 if (mPaint->getShader() && !mPaint->getShader()->isOpaque()) { 203 return false; 204 } 205 if (PaintUtils::isBlendedColorFilter(mPaint->getColorFilter())) { 206 return false; 207 } 208 } 209 210 if (state.mAlpha != 1.0f) return false; 211 212 SkXfermode::Mode mode = PaintUtils::getXfermodeDirect(mPaint); 213 return (mode == SkXfermode::kSrcOver_Mode || 214 mode == SkXfermode::kSrc_Mode); 215 216 } 217 218 const SkPaint* mPaint; 219 bool mQuickRejected; 220}; 221 222class DrawBoundedOp : public DrawOp { 223public: 224 DrawBoundedOp(float left, float top, float right, float bottom, const SkPaint* paint) 225 : DrawOp(paint), mLocalBounds(left, top, right, bottom) {} 226 227 DrawBoundedOp(const Rect& localBounds, const SkPaint* paint) 228 : DrawOp(paint), mLocalBounds(localBounds) {} 229 230 // Calculates bounds as smallest rect encompassing all points 231 // NOTE: requires at least 1 vertex, and doesn't account for stroke size (should be handled in 232 // subclass' constructor) 233 DrawBoundedOp(const float* points, int count, const SkPaint* paint) 234 : DrawOp(paint), mLocalBounds(points[0], points[1], points[0], points[1]) { 235 for (int i = 2; i < count; i += 2) { 236 mLocalBounds.left = std::min(mLocalBounds.left, points[i]); 237 mLocalBounds.right = std::max(mLocalBounds.right, points[i]); 238 mLocalBounds.top = std::min(mLocalBounds.top, points[i + 1]); 239 mLocalBounds.bottom = std::max(mLocalBounds.bottom, points[i + 1]); 240 } 241 } 242 243 // default empty constructor for bounds, to be overridden in child constructor body 244 DrawBoundedOp(const SkPaint* paint): DrawOp(paint) { } 245 246 virtual bool getLocalBounds(Rect& localBounds) override { 247 localBounds.set(mLocalBounds); 248 PaintUtils::TextShadow textShadow; 249 if (PaintUtils::getTextShadow(mPaint, &textShadow)) { 250 Rect shadow(mLocalBounds); 251 shadow.translate(textShadow.dx, textShadow.dx); 252 shadow.outset(textShadow.radius); 253 localBounds.unionWith(shadow); 254 } 255 return true; 256 } 257 258protected: 259 Rect mLocalBounds; // displayed area in LOCAL coord. doesn't incorporate stroke, so check paint 260}; 261 262/////////////////////////////////////////////////////////////////////////////// 263// STATE OPERATIONS - these may affect the state of the canvas/renderer, but do 264// not directly draw or alter output 265/////////////////////////////////////////////////////////////////////////////// 266 267class SaveOp : public StateOp { 268public: 269 SaveOp(int flags) 270 : mFlags(flags) {} 271 272 virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level, 273 bool useQuickReject) override { 274 int newSaveCount = deferStruct.mRenderer.save(mFlags); 275 deferStruct.mDeferredList.addSave(deferStruct.mRenderer, this, newSaveCount); 276 } 277 278 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 279 renderer.save(mFlags); 280 } 281 282 virtual void output(int level, uint32_t logFlags) const override { 283 OP_LOG("Save flags %x", mFlags); 284 } 285 286 virtual const char* name() override { return "Save"; } 287 288 int getFlags() const { return mFlags; } 289private: 290 int mFlags; 291}; 292 293class RestoreToCountOp : public StateOp { 294public: 295 RestoreToCountOp(int count) 296 : mCount(count) {} 297 298 virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level, 299 bool useQuickReject) override { 300 deferStruct.mDeferredList.addRestoreToCount(deferStruct.mRenderer, 301 this, saveCount + mCount); 302 deferStruct.mRenderer.restoreToCount(saveCount + mCount); 303 } 304 305 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 306 renderer.restoreToCount(saveCount + mCount); 307 } 308 309 virtual void output(int level, uint32_t logFlags) const override { 310 OP_LOG("Restore to count %d", mCount); 311 } 312 313 virtual const char* name() override { return "RestoreToCount"; } 314 315private: 316 int mCount; 317}; 318 319class SaveLayerOp : public StateOp { 320public: 321 SaveLayerOp(float left, float top, float right, float bottom, int alpha, int flags) 322 : mArea(left, top, right, bottom) 323 , mPaint(&mCachedPaint) 324 , mFlags(flags) 325 , mConvexMask(nullptr) { 326 mCachedPaint.setAlpha(alpha); 327 } 328 329 SaveLayerOp(float left, float top, float right, float bottom, const SkPaint* paint, int flags) 330 : mArea(left, top, right, bottom) 331 , mPaint(paint) 332 , mFlags(flags) 333 , mConvexMask(nullptr) 334 {} 335 336 virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level, 337 bool useQuickReject) override { 338 // NOTE: don't bother with actual saveLayer, instead issuing it at flush time 339 int newSaveCount = deferStruct.mRenderer.getSaveCount(); 340 deferStruct.mDeferredList.addSaveLayer(deferStruct.mRenderer, this, newSaveCount); 341 342 // NOTE: don't issue full saveLayer, since that has side effects/is costly. instead just 343 // setup the snapshot for deferral, and re-issue the op at flush time 344 deferStruct.mRenderer.saveLayerDeferred(mArea.left, mArea.top, mArea.right, mArea.bottom, 345 mPaint, mFlags); 346 } 347 348 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 349 renderer.saveLayer(mArea.left, mArea.top, mArea.right, mArea.bottom, 350 mPaint, mFlags, mConvexMask); 351 } 352 353 virtual void output(int level, uint32_t logFlags) const override { 354 OP_LOG("SaveLayer%s of area " RECT_STRING, 355 (isSaveLayerAlpha() ? "Alpha" : ""),RECT_ARGS(mArea)); 356 } 357 358 virtual const char* name() override { 359 return isSaveLayerAlpha() ? "SaveLayerAlpha" : "SaveLayer"; 360 } 361 362 int getFlags() { return mFlags; } 363 364 // Called to make SaveLayerOp clip to the provided mask when drawing back/restored 365 void setMask(const SkPath* convexMask) { 366 mConvexMask = convexMask; 367 } 368 369private: 370 bool isSaveLayerAlpha() const { 371 SkXfermode::Mode mode = PaintUtils::getXfermodeDirect(mPaint); 372 int alpha = PaintUtils::getAlphaDirect(mPaint); 373 return alpha < 255 && mode == SkXfermode::kSrcOver_Mode; 374 } 375 376 Rect mArea; 377 const SkPaint* mPaint; 378 SkPaint mCachedPaint; 379 int mFlags; 380 381 // Convex path, points at data in RenderNode, valid for the duration of the frame only 382 // Only used for masking the SaveLayer which wraps projected RenderNodes 383 const SkPath* mConvexMask; 384}; 385 386class TranslateOp : public StateOp { 387public: 388 TranslateOp(float dx, float dy) 389 : mDx(dx), mDy(dy) {} 390 391 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 392 renderer.translate(mDx, mDy); 393 } 394 395 virtual void output(int level, uint32_t logFlags) const override { 396 OP_LOG("Translate by %f %f", mDx, mDy); 397 } 398 399 virtual const char* name() override { return "Translate"; } 400 401private: 402 float mDx; 403 float mDy; 404}; 405 406class RotateOp : public StateOp { 407public: 408 RotateOp(float degrees) 409 : mDegrees(degrees) {} 410 411 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 412 renderer.rotate(mDegrees); 413 } 414 415 virtual void output(int level, uint32_t logFlags) const override { 416 OP_LOG("Rotate by %f degrees", mDegrees); 417 } 418 419 virtual const char* name() override { return "Rotate"; } 420 421private: 422 float mDegrees; 423}; 424 425class ScaleOp : public StateOp { 426public: 427 ScaleOp(float sx, float sy) 428 : mSx(sx), mSy(sy) {} 429 430 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 431 renderer.scale(mSx, mSy); 432 } 433 434 virtual void output(int level, uint32_t logFlags) const override { 435 OP_LOG("Scale by %f %f", mSx, mSy); 436 } 437 438 virtual const char* name() override { return "Scale"; } 439 440private: 441 float mSx; 442 float mSy; 443}; 444 445class SkewOp : public StateOp { 446public: 447 SkewOp(float sx, float sy) 448 : mSx(sx), mSy(sy) {} 449 450 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 451 renderer.skew(mSx, mSy); 452 } 453 454 virtual void output(int level, uint32_t logFlags) const override { 455 OP_LOG("Skew by %f %f", mSx, mSy); 456 } 457 458 virtual const char* name() override { return "Skew"; } 459 460private: 461 float mSx; 462 float mSy; 463}; 464 465class SetMatrixOp : public StateOp { 466public: 467 SetMatrixOp(const SkMatrix& matrix) 468 : mMatrix(matrix) {} 469 470 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 471 // Setting a matrix on a Canvas isn't equivalent to setting a total matrix on the scene. 472 // Set a canvas-relative matrix on the renderer instead. 473 renderer.setLocalMatrix(mMatrix); 474 } 475 476 virtual void output(int level, uint32_t logFlags) const override { 477 if (mMatrix.isIdentity()) { 478 OP_LOGS("SetMatrix (reset)"); 479 } else { 480 OP_LOG("SetMatrix " SK_MATRIX_STRING, SK_MATRIX_ARGS(&mMatrix)); 481 } 482 } 483 484 virtual const char* name() override { return "SetMatrix"; } 485 486private: 487 const SkMatrix mMatrix; 488}; 489 490class ConcatMatrixOp : public StateOp { 491public: 492 ConcatMatrixOp(const SkMatrix& matrix) 493 : mMatrix(matrix) {} 494 495 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 496 renderer.concatMatrix(mMatrix); 497 } 498 499 virtual void output(int level, uint32_t logFlags) const override { 500 OP_LOG("ConcatMatrix " SK_MATRIX_STRING, SK_MATRIX_ARGS(&mMatrix)); 501 } 502 503 virtual const char* name() override { return "ConcatMatrix"; } 504 505private: 506 const SkMatrix mMatrix; 507}; 508 509class ClipOp : public StateOp { 510public: 511 ClipOp(SkRegion::Op op) : mOp(op) {} 512 513 virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level, 514 bool useQuickReject) override { 515 // NOTE: must defer op BEFORE applying state, since it may read clip 516 deferStruct.mDeferredList.addClip(deferStruct.mRenderer, this); 517 518 // TODO: Can we avoid applying complex clips at defer time? 519 applyState(deferStruct.mRenderer, saveCount); 520 } 521 522 bool canCauseComplexClip() { 523 return ((mOp != SkRegion::kIntersect_Op) && (mOp != SkRegion::kReplace_Op)) || !isRect(); 524 } 525 526protected: 527 virtual bool isRect() { return false; } 528 529 SkRegion::Op mOp; 530}; 531 532class ClipRectOp : public ClipOp { 533public: 534 ClipRectOp(float left, float top, float right, float bottom, SkRegion::Op op) 535 : ClipOp(op), mArea(left, top, right, bottom) {} 536 537 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 538 renderer.clipRect(mArea.left, mArea.top, mArea.right, mArea.bottom, mOp); 539 } 540 541 virtual void output(int level, uint32_t logFlags) const override { 542 OP_LOG("ClipRect " RECT_STRING, RECT_ARGS(mArea)); 543 } 544 545 virtual const char* name() override { return "ClipRect"; } 546 547protected: 548 virtual bool isRect() override { return true; } 549 550private: 551 Rect mArea; 552}; 553 554class ClipPathOp : public ClipOp { 555public: 556 ClipPathOp(const SkPath* path, SkRegion::Op op) 557 : ClipOp(op), mPath(path) {} 558 559 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 560 renderer.clipPath(mPath, mOp); 561 } 562 563 virtual void output(int level, uint32_t logFlags) const override { 564 SkRect bounds = mPath->getBounds(); 565 OP_LOG("ClipPath bounds " RECT_STRING, 566 bounds.left(), bounds.top(), bounds.right(), bounds.bottom()); 567 } 568 569 virtual const char* name() override { return "ClipPath"; } 570 571private: 572 const SkPath* mPath; 573}; 574 575class ClipRegionOp : public ClipOp { 576public: 577 ClipRegionOp(const SkRegion* region, SkRegion::Op op) 578 : ClipOp(op), mRegion(region) {} 579 580 virtual void applyState(OpenGLRenderer& renderer, int saveCount) const override { 581 renderer.clipRegion(mRegion, mOp); 582 } 583 584 virtual void output(int level, uint32_t logFlags) const override { 585 SkIRect bounds = mRegion->getBounds(); 586 OP_LOG("ClipRegion bounds %d %d %d %d", 587 bounds.left(), bounds.top(), bounds.right(), bounds.bottom()); 588 } 589 590 virtual const char* name() override { return "ClipRegion"; } 591 592private: 593 const SkRegion* mRegion; 594}; 595 596/////////////////////////////////////////////////////////////////////////////// 597// DRAW OPERATIONS - these are operations that can draw to the canvas's device 598/////////////////////////////////////////////////////////////////////////////// 599 600class DrawBitmapOp : public DrawBoundedOp { 601public: 602 DrawBitmapOp(const SkBitmap* bitmap, const SkPaint* paint) 603 : DrawBoundedOp(0, 0, bitmap->width(), bitmap->height(), paint) 604 , mBitmap(bitmap) 605 , mEntryValid(false), mEntry(nullptr) { 606 } 607 608 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 609 renderer.drawBitmap(mBitmap, mPaint); 610 } 611 612 AssetAtlas::Entry* getAtlasEntry(OpenGLRenderer& renderer) { 613 if (!mEntryValid) { 614 mEntryValid = true; 615 mEntry = renderer.renderState().assetAtlas().getEntry(mBitmap); 616 } 617 return mEntry; 618 } 619 620#define SET_TEXTURE(ptr, posRect, offsetRect, texCoordsRect, xDim, yDim) \ 621 TextureVertex::set(ptr++, posRect.xDim - offsetRect.left, posRect.yDim - offsetRect.top, \ 622 texCoordsRect.xDim, texCoordsRect.yDim) 623 624 /** 625 * This multi-draw operation builds a mesh on the stack by generating a quad 626 * for each bitmap in the batch. This method is also responsible for dirtying 627 * the current layer, if any. 628 */ 629 virtual void multiDraw(OpenGLRenderer& renderer, Rect& dirty, 630 const std::vector<OpStatePair>& ops, const Rect& bounds) override { 631 const DeferredDisplayState& firstState = *(ops[0].state); 632 renderer.restoreDisplayState(firstState, true); // restore all but the clip 633 634 TextureVertex vertices[6 * ops.size()]; 635 TextureVertex* vertex = &vertices[0]; 636 637 const bool hasLayer = renderer.hasLayer(); 638 bool pureTranslate = true; 639 640 // TODO: manually handle rect clip for bitmaps by adjusting texCoords per op, 641 // and allowing them to be merged in getBatchId() 642 for (unsigned int i = 0; i < ops.size(); i++) { 643 const DeferredDisplayState& state = *(ops[i].state); 644 const Rect& opBounds = state.mBounds; 645 // When we reach multiDraw(), the matrix can be either 646 // pureTranslate or simple (translate and/or scale). 647 // If the matrix is not pureTranslate, then we have a scale 648 pureTranslate &= state.mMatrix.isPureTranslate(); 649 650 Rect texCoords(0, 0, 1, 1); 651 ((DrawBitmapOp*) ops[i].op)->uvMap(renderer, texCoords); 652 653 SET_TEXTURE(vertex, opBounds, bounds, texCoords, left, top); 654 SET_TEXTURE(vertex, opBounds, bounds, texCoords, right, top); 655 SET_TEXTURE(vertex, opBounds, bounds, texCoords, left, bottom); 656 657 SET_TEXTURE(vertex, opBounds, bounds, texCoords, left, bottom); 658 SET_TEXTURE(vertex, opBounds, bounds, texCoords, right, top); 659 SET_TEXTURE(vertex, opBounds, bounds, texCoords, right, bottom); 660 661 if (hasLayer) { 662 renderer.dirtyLayer(opBounds.left, opBounds.top, opBounds.right, opBounds.bottom); 663 } 664 } 665 666 renderer.drawBitmaps(mBitmap, mEntry, ops.size(), &vertices[0], 667 pureTranslate, bounds, mPaint); 668 } 669 670 virtual void output(int level, uint32_t logFlags) const override { 671 OP_LOG("Draw bitmap %p of size %dx%d%s", 672 mBitmap, mBitmap->width(), mBitmap->height(), 673 mEntry ? " using AssetAtlas" : ""); 674 } 675 676 virtual const char* name() override { return "DrawBitmap"; } 677 678 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 679 const DeferredDisplayState& state) override { 680 deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap; 681 deferInfo.mergeId = getAtlasEntry(renderer) ? 682 (mergeid_t) mEntry->getMergeId() : (mergeid_t) mBitmap; 683 684 // Don't merge non-simply transformed or neg scale ops, SET_TEXTURE doesn't handle rotation 685 // Don't merge A8 bitmaps - the paint's color isn't compared by mergeId, or in 686 // MergingDrawBatch::canMergeWith() 687 // TODO: support clipped bitmaps by handling them in SET_TEXTURE 688 deferInfo.mergeable = state.mMatrix.isSimple() && state.mMatrix.positiveScale() && 689 !state.mClipSideFlags && 690 PaintUtils::getXfermodeDirect(mPaint) == SkXfermode::kSrcOver_Mode && 691 (mBitmap->colorType() != kAlpha_8_SkColorType); 692 } 693 694 void uvMap(OpenGLRenderer& renderer, Rect& texCoords) { 695 if (getAtlasEntry(renderer)) { 696 mEntry->uvMapper.map(texCoords); 697 } 698 } 699 700 const SkBitmap* bitmap() { return mBitmap; } 701protected: 702 const SkBitmap* mBitmap; 703 bool mEntryValid; 704 AssetAtlas::Entry* mEntry; 705}; 706 707class DrawBitmapRectOp : public DrawBoundedOp { 708public: 709 DrawBitmapRectOp(const SkBitmap* bitmap, 710 float srcLeft, float srcTop, float srcRight, float srcBottom, 711 float dstLeft, float dstTop, float dstRight, float dstBottom, const SkPaint* paint) 712 : DrawBoundedOp(dstLeft, dstTop, dstRight, dstBottom, paint), 713 mBitmap(bitmap), mSrc(srcLeft, srcTop, srcRight, srcBottom) {} 714 715 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 716 renderer.drawBitmap(mBitmap, mSrc, mLocalBounds, mPaint); 717 } 718 719 virtual void output(int level, uint32_t logFlags) const override { 720 OP_LOG("Draw bitmap %p src=" RECT_STRING ", dst=" RECT_STRING, 721 mBitmap, RECT_ARGS(mSrc), RECT_ARGS(mLocalBounds)); 722 } 723 724 virtual const char* name() override { return "DrawBitmapRect"; } 725 726 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 727 const DeferredDisplayState& state) override { 728 deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap; 729 } 730 731private: 732 const SkBitmap* mBitmap; 733 Rect mSrc; 734}; 735 736class DrawBitmapMeshOp : public DrawBoundedOp { 737public: 738 DrawBitmapMeshOp(const SkBitmap* bitmap, int meshWidth, int meshHeight, 739 const float* vertices, const int* colors, const SkPaint* paint) 740 : DrawBoundedOp(vertices, 2 * (meshWidth + 1) * (meshHeight + 1), paint), 741 mBitmap(bitmap), mMeshWidth(meshWidth), mMeshHeight(meshHeight), 742 mVertices(vertices), mColors(colors) {} 743 744 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 745 renderer.drawBitmapMesh(mBitmap, mMeshWidth, mMeshHeight, 746 mVertices, mColors, mPaint); 747 } 748 749 virtual void output(int level, uint32_t logFlags) const override { 750 OP_LOG("Draw bitmap %p mesh %d x %d", mBitmap, mMeshWidth, mMeshHeight); 751 } 752 753 virtual const char* name() override { return "DrawBitmapMesh"; } 754 755 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 756 const DeferredDisplayState& state) override { 757 deferInfo.batchId = DeferredDisplayList::kOpBatch_Bitmap; 758 } 759 760private: 761 const SkBitmap* mBitmap; 762 int mMeshWidth; 763 int mMeshHeight; 764 const float* mVertices; 765 const int* mColors; 766}; 767 768class DrawPatchOp : public DrawBoundedOp { 769public: 770 DrawPatchOp(const SkBitmap* bitmap, const Res_png_9patch* patch, 771 float left, float top, float right, float bottom, const SkPaint* paint) 772 : DrawBoundedOp(left, top, right, bottom, paint), 773 mBitmap(bitmap), mPatch(patch), mGenerationId(0), mMesh(nullptr), 774 mEntryValid(false), mEntry(nullptr) { 775 }; 776 777 AssetAtlas::Entry* getAtlasEntry(OpenGLRenderer& renderer) { 778 if (!mEntryValid) { 779 mEntryValid = true; 780 mEntry = renderer.renderState().assetAtlas().getEntry(mBitmap); 781 } 782 return mEntry; 783 } 784 785 const Patch* getMesh(OpenGLRenderer& renderer) { 786 if (!mMesh || renderer.getCaches().patchCache.getGenerationId() != mGenerationId) { 787 PatchCache& cache = renderer.getCaches().patchCache; 788 mMesh = cache.get(getAtlasEntry(renderer), mBitmap->width(), mBitmap->height(), 789 mLocalBounds.getWidth(), mLocalBounds.getHeight(), mPatch); 790 mGenerationId = cache.getGenerationId(); 791 } 792 return mMesh; 793 } 794 795 /** 796 * This multi-draw operation builds an indexed mesh on the stack by copying 797 * and transforming the vertices of each 9-patch in the batch. This method 798 * is also responsible for dirtying the current layer, if any. 799 */ 800 virtual void multiDraw(OpenGLRenderer& renderer, Rect& dirty, 801 const std::vector<OpStatePair>& ops, const Rect& bounds) override { 802 const DeferredDisplayState& firstState = *(ops[0].state); 803 renderer.restoreDisplayState(firstState, true); // restore all but the clip 804 805 // Batches will usually contain a small number of items so it's 806 // worth performing a first iteration to count the exact number 807 // of vertices we need in the new mesh 808 uint32_t totalVertices = 0; 809 for (unsigned int i = 0; i < ops.size(); i++) { 810 totalVertices += ((DrawPatchOp*) ops[i].op)->getMesh(renderer)->verticesCount; 811 } 812 813 const bool hasLayer = renderer.hasLayer(); 814 815 uint32_t indexCount = 0; 816 817 TextureVertex vertices[totalVertices]; 818 TextureVertex* vertex = &vertices[0]; 819 820 // Create a mesh that contains the transformed vertices for all the 821 // 9-patch objects that are part of the batch. Note that onDefer() 822 // enforces ops drawn by this function to have a pure translate or 823 // identity matrix 824 for (unsigned int i = 0; i < ops.size(); i++) { 825 DrawPatchOp* patchOp = (DrawPatchOp*) ops[i].op; 826 const DeferredDisplayState* state = ops[i].state; 827 const Patch* opMesh = patchOp->getMesh(renderer); 828 uint32_t vertexCount = opMesh->verticesCount; 829 if (vertexCount == 0) continue; 830 831 // We use the bounds to know where to translate our vertices 832 // Using patchOp->state.mBounds wouldn't work because these 833 // bounds are clipped 834 const float tx = (int) floorf(state->mMatrix.getTranslateX() + 835 patchOp->mLocalBounds.left + 0.5f); 836 const float ty = (int) floorf(state->mMatrix.getTranslateY() + 837 patchOp->mLocalBounds.top + 0.5f); 838 839 // Copy & transform all the vertices for the current operation 840 TextureVertex* opVertices = opMesh->vertices.get(); 841 for (uint32_t j = 0; j < vertexCount; j++, opVertices++) { 842 TextureVertex::set(vertex++, 843 opVertices->x + tx, opVertices->y + ty, 844 opVertices->u, opVertices->v); 845 } 846 847 // Dirty the current layer if possible. When the 9-patch does not 848 // contain empty quads we can take a shortcut and simply set the 849 // dirty rect to the object's bounds. 850 if (hasLayer) { 851 if (!opMesh->hasEmptyQuads) { 852 renderer.dirtyLayer(tx, ty, 853 tx + patchOp->mLocalBounds.getWidth(), 854 ty + patchOp->mLocalBounds.getHeight()); 855 } else { 856 const size_t count = opMesh->quads.size(); 857 for (size_t i = 0; i < count; i++) { 858 const Rect& quadBounds = opMesh->quads[i]; 859 const float x = tx + quadBounds.left; 860 const float y = ty + quadBounds.top; 861 renderer.dirtyLayer(x, y, 862 x + quadBounds.getWidth(), y + quadBounds.getHeight()); 863 } 864 } 865 } 866 867 indexCount += opMesh->indexCount; 868 } 869 870 renderer.drawPatches(mBitmap, getAtlasEntry(renderer), 871 &vertices[0], indexCount, mPaint); 872 } 873 874 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 875 // We're not calling the public variant of drawPatch() here 876 // This method won't perform the quickReject() since we've already done it at this point 877 renderer.drawPatch(mBitmap, getMesh(renderer), getAtlasEntry(renderer), 878 mLocalBounds.left, mLocalBounds.top, mLocalBounds.right, mLocalBounds.bottom, 879 mPaint); 880 } 881 882 virtual void output(int level, uint32_t logFlags) const override { 883 OP_LOG("Draw patch " RECT_STRING "%s", RECT_ARGS(mLocalBounds), 884 mEntry ? " with AssetAtlas" : ""); 885 } 886 887 virtual const char* name() override { return "DrawPatch"; } 888 889 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 890 const DeferredDisplayState& state) override { 891 deferInfo.batchId = DeferredDisplayList::kOpBatch_Patch; 892 deferInfo.mergeId = getAtlasEntry(renderer) ? (mergeid_t) mEntry->getMergeId() : (mergeid_t) mBitmap; 893 deferInfo.mergeable = state.mMatrix.isPureTranslate() && 894 PaintUtils::getXfermodeDirect(mPaint) == SkXfermode::kSrcOver_Mode; 895 deferInfo.opaqueOverBounds = isOpaqueOverBounds(state) && mBitmap->isOpaque(); 896 } 897 898private: 899 const SkBitmap* mBitmap; 900 const Res_png_9patch* mPatch; 901 902 uint32_t mGenerationId; 903 const Patch* mMesh; 904 905 bool mEntryValid; 906 AssetAtlas::Entry* mEntry; 907}; 908 909class DrawColorOp : public DrawOp { 910public: 911 DrawColorOp(int color, SkXfermode::Mode mode) 912 : DrawOp(nullptr), mColor(color), mMode(mode) {}; 913 914 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 915 renderer.drawColor(mColor, mMode); 916 } 917 918 virtual void output(int level, uint32_t logFlags) const override { 919 OP_LOG("Draw color %#x, mode %d", mColor, mMode); 920 } 921 922 virtual const char* name() override { return "DrawColor"; } 923 924private: 925 int mColor; 926 SkXfermode::Mode mMode; 927}; 928 929class DrawStrokableOp : public DrawBoundedOp { 930public: 931 DrawStrokableOp(float left, float top, float right, float bottom, const SkPaint* paint) 932 : DrawBoundedOp(left, top, right, bottom, paint) {}; 933 DrawStrokableOp(const Rect& localBounds, const SkPaint* paint) 934 : DrawBoundedOp(localBounds, paint) {}; 935 936 virtual bool getLocalBounds(Rect& localBounds) override { 937 localBounds.set(mLocalBounds); 938 if (mPaint && mPaint->getStyle() != SkPaint::kFill_Style) { 939 localBounds.outset(strokeWidthOutset()); 940 } 941 return true; 942 } 943 944 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 945 const DeferredDisplayState& state) override { 946 if (mPaint->getPathEffect()) { 947 deferInfo.batchId = DeferredDisplayList::kOpBatch_AlphaMaskTexture; 948 } else { 949 deferInfo.batchId = mPaint->isAntiAlias() ? 950 DeferredDisplayList::kOpBatch_AlphaVertices : 951 DeferredDisplayList::kOpBatch_Vertices; 952 } 953 } 954}; 955 956class DrawRectOp : public DrawStrokableOp { 957public: 958 DrawRectOp(float left, float top, float right, float bottom, const SkPaint* paint) 959 : DrawStrokableOp(left, top, right, bottom, paint) {} 960 961 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 962 renderer.drawRect(mLocalBounds.left, mLocalBounds.top, 963 mLocalBounds.right, mLocalBounds.bottom, mPaint); 964 } 965 966 virtual void output(int level, uint32_t logFlags) const override { 967 OP_LOG("Draw Rect " RECT_STRING, RECT_ARGS(mLocalBounds)); 968 } 969 970 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 971 const DeferredDisplayState& state) override { 972 DrawStrokableOp::onDefer(renderer, deferInfo, state); 973 deferInfo.opaqueOverBounds = isOpaqueOverBounds(state) && 974 mPaint->getStyle() == SkPaint::kFill_Style; 975 } 976 977 virtual const char* name() override { return "DrawRect"; } 978}; 979 980class DrawRectsOp : public DrawBoundedOp { 981public: 982 DrawRectsOp(const float* rects, int count, const SkPaint* paint) 983 : DrawBoundedOp(rects, count, paint), 984 mRects(rects), mCount(count) {} 985 986 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 987 renderer.drawRects(mRects, mCount, mPaint); 988 } 989 990 virtual void output(int level, uint32_t logFlags) const override { 991 OP_LOG("Draw Rects count %d", mCount); 992 } 993 994 virtual const char* name() override { return "DrawRects"; } 995 996 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 997 const DeferredDisplayState& state) override { 998 deferInfo.batchId = DeferredDisplayList::kOpBatch_Vertices; 999 } 1000 1001private: 1002 const float* mRects; 1003 int mCount; 1004}; 1005 1006class DrawRoundRectOp : public DrawStrokableOp { 1007public: 1008 DrawRoundRectOp(float left, float top, float right, float bottom, 1009 float rx, float ry, const SkPaint* paint) 1010 : DrawStrokableOp(left, top, right, bottom, paint), mRx(rx), mRy(ry) {} 1011 1012 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1013 renderer.drawRoundRect(mLocalBounds.left, mLocalBounds.top, 1014 mLocalBounds.right, mLocalBounds.bottom, mRx, mRy, mPaint); 1015 } 1016 1017 virtual void output(int level, uint32_t logFlags) const override { 1018 OP_LOG("Draw RoundRect " RECT_STRING ", rx %f, ry %f", RECT_ARGS(mLocalBounds), mRx, mRy); 1019 } 1020 1021 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 1022 const DeferredDisplayState& state) override { 1023 DrawStrokableOp::onDefer(renderer, deferInfo, state); 1024 if (!mPaint->getPathEffect()) { 1025 renderer.getCaches().tessellationCache.precacheRoundRect(state.mMatrix, *mPaint, 1026 mLocalBounds.getWidth(), mLocalBounds.getHeight(), mRx, mRy); 1027 } 1028 } 1029 1030 virtual const char* name() override { return "DrawRoundRect"; } 1031 1032private: 1033 float mRx; 1034 float mRy; 1035}; 1036 1037class DrawRoundRectPropsOp : public DrawOp { 1038public: 1039 DrawRoundRectPropsOp(float* left, float* top, float* right, float* bottom, 1040 float *rx, float *ry, const SkPaint* paint) 1041 : DrawOp(paint), mLeft(left), mTop(top), mRight(right), mBottom(bottom), 1042 mRx(rx), mRy(ry) {} 1043 1044 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1045 renderer.drawRoundRect(*mLeft, *mTop, *mRight, *mBottom, 1046 *mRx, *mRy, mPaint); 1047 } 1048 1049 virtual void output(int level, uint32_t logFlags) const override { 1050 OP_LOG("Draw RoundRect Props " RECT_STRING ", rx %f, ry %f", 1051 *mLeft, *mTop, *mRight, *mBottom, *mRx, *mRy); 1052 } 1053 1054 virtual const char* name() override { return "DrawRoundRectProps"; } 1055 1056private: 1057 float* mLeft; 1058 float* mTop; 1059 float* mRight; 1060 float* mBottom; 1061 float* mRx; 1062 float* mRy; 1063}; 1064 1065class DrawCircleOp : public DrawStrokableOp { 1066public: 1067 DrawCircleOp(float x, float y, float radius, const SkPaint* paint) 1068 : DrawStrokableOp(x - radius, y - radius, x + radius, y + radius, paint), 1069 mX(x), mY(y), mRadius(radius) {} 1070 1071 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1072 renderer.drawCircle(mX, mY, mRadius, mPaint); 1073 } 1074 1075 virtual void output(int level, uint32_t logFlags) const override { 1076 OP_LOG("Draw Circle x %f, y %f, r %f", mX, mY, mRadius); 1077 } 1078 1079 virtual const char* name() override { return "DrawCircle"; } 1080 1081private: 1082 float mX; 1083 float mY; 1084 float mRadius; 1085}; 1086 1087class DrawCirclePropsOp : public DrawOp { 1088public: 1089 DrawCirclePropsOp(float* x, float* y, float* radius, const SkPaint* paint) 1090 : DrawOp(paint), mX(x), mY(y), mRadius(radius) {} 1091 1092 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1093 renderer.drawCircle(*mX, *mY, *mRadius, mPaint); 1094 } 1095 1096 virtual void output(int level, uint32_t logFlags) const override { 1097 OP_LOG("Draw Circle Props x %p, y %p, r %p", mX, mY, mRadius); 1098 } 1099 1100 virtual const char* name() override { return "DrawCircleProps"; } 1101 1102private: 1103 float* mX; 1104 float* mY; 1105 float* mRadius; 1106}; 1107 1108class DrawOvalOp : public DrawStrokableOp { 1109public: 1110 DrawOvalOp(float left, float top, float right, float bottom, const SkPaint* paint) 1111 : DrawStrokableOp(left, top, right, bottom, paint) {} 1112 1113 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1114 renderer.drawOval(mLocalBounds.left, mLocalBounds.top, 1115 mLocalBounds.right, mLocalBounds.bottom, mPaint); 1116 } 1117 1118 virtual void output(int level, uint32_t logFlags) const override { 1119 OP_LOG("Draw Oval " RECT_STRING, RECT_ARGS(mLocalBounds)); 1120 } 1121 1122 virtual const char* name() override { return "DrawOval"; } 1123}; 1124 1125class DrawArcOp : public DrawStrokableOp { 1126public: 1127 DrawArcOp(float left, float top, float right, float bottom, 1128 float startAngle, float sweepAngle, bool useCenter, const SkPaint* paint) 1129 : DrawStrokableOp(left, top, right, bottom, paint), 1130 mStartAngle(startAngle), mSweepAngle(sweepAngle), mUseCenter(useCenter) {} 1131 1132 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1133 renderer.drawArc(mLocalBounds.left, mLocalBounds.top, 1134 mLocalBounds.right, mLocalBounds.bottom, 1135 mStartAngle, mSweepAngle, mUseCenter, mPaint); 1136 } 1137 1138 virtual void output(int level, uint32_t logFlags) const override { 1139 OP_LOG("Draw Arc " RECT_STRING ", start %f, sweep %f, useCenter %d", 1140 RECT_ARGS(mLocalBounds), mStartAngle, mSweepAngle, mUseCenter); 1141 } 1142 1143 virtual const char* name() override { return "DrawArc"; } 1144 1145private: 1146 float mStartAngle; 1147 float mSweepAngle; 1148 bool mUseCenter; 1149}; 1150 1151class DrawPathOp : public DrawBoundedOp { 1152public: 1153 DrawPathOp(const SkPath* path, const SkPaint* paint) 1154 : DrawBoundedOp(paint), mPath(path) { 1155 float left, top, offset; 1156 uint32_t width, height; 1157 PathCache::computePathBounds(path, paint, left, top, offset, width, height); 1158 left -= offset; 1159 top -= offset; 1160 mLocalBounds.set(left, top, left + width, top + height); 1161 } 1162 1163 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1164 renderer.drawPath(mPath, mPaint); 1165 } 1166 1167 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 1168 const DeferredDisplayState& state) override { 1169 renderer.getCaches().pathCache.precache(mPath, mPaint); 1170 1171 deferInfo.batchId = DeferredDisplayList::kOpBatch_AlphaMaskTexture; 1172 } 1173 1174 virtual void output(int level, uint32_t logFlags) const override { 1175 OP_LOG("Draw Path %p in " RECT_STRING, mPath, RECT_ARGS(mLocalBounds)); 1176 } 1177 1178 virtual const char* name() override { return "DrawPath"; } 1179 1180private: 1181 const SkPath* mPath; 1182}; 1183 1184class DrawLinesOp : public DrawBoundedOp { 1185public: 1186 DrawLinesOp(const float* points, int count, const SkPaint* paint) 1187 : DrawBoundedOp(points, count, paint), 1188 mPoints(points), mCount(count) { 1189 mLocalBounds.outset(strokeWidthOutset()); 1190 } 1191 1192 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1193 renderer.drawLines(mPoints, mCount, mPaint); 1194 } 1195 1196 virtual void output(int level, uint32_t logFlags) const override { 1197 OP_LOG("Draw Lines count %d", mCount); 1198 } 1199 1200 virtual const char* name() override { return "DrawLines"; } 1201 1202 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 1203 const DeferredDisplayState& state) override { 1204 deferInfo.batchId = mPaint->isAntiAlias() ? 1205 DeferredDisplayList::kOpBatch_AlphaVertices : 1206 DeferredDisplayList::kOpBatch_Vertices; 1207 } 1208 1209protected: 1210 const float* mPoints; 1211 int mCount; 1212}; 1213 1214class DrawPointsOp : public DrawLinesOp { 1215public: 1216 DrawPointsOp(const float* points, int count, const SkPaint* paint) 1217 : DrawLinesOp(points, count, paint) {} 1218 1219 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1220 renderer.drawPoints(mPoints, mCount, mPaint); 1221 } 1222 1223 virtual void output(int level, uint32_t logFlags) const override { 1224 OP_LOG("Draw Points count %d", mCount); 1225 } 1226 1227 virtual const char* name() override { return "DrawPoints"; } 1228}; 1229 1230class DrawSomeTextOp : public DrawOp { 1231public: 1232 DrawSomeTextOp(const char* text, int bytesCount, int count, const SkPaint* paint) 1233 : DrawOp(paint), mText(text), mBytesCount(bytesCount), mCount(count) {}; 1234 1235 virtual void output(int level, uint32_t logFlags) const override { 1236 OP_LOG("Draw some text, %d bytes", mBytesCount); 1237 } 1238 1239 virtual bool hasTextShadow() const override { 1240 return PaintUtils::hasTextShadow(mPaint); 1241 } 1242 1243 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 1244 const DeferredDisplayState& state) override { 1245 FontRenderer& fontRenderer = renderer.getCaches().fontRenderer.getFontRenderer(); 1246 fontRenderer.precache(mPaint, mText, mCount, SkMatrix::I()); 1247 1248 deferInfo.batchId = mPaint->getColor() == SK_ColorBLACK ? 1249 DeferredDisplayList::kOpBatch_Text : 1250 DeferredDisplayList::kOpBatch_ColorText; 1251 } 1252 1253protected: 1254 const char* mText; 1255 int mBytesCount; 1256 int mCount; 1257}; 1258 1259class DrawTextOnPathOp : public DrawSomeTextOp { 1260public: 1261 DrawTextOnPathOp(const char* text, int bytesCount, int count, 1262 const SkPath* path, float hOffset, float vOffset, const SkPaint* paint) 1263 : DrawSomeTextOp(text, bytesCount, count, paint), 1264 mPath(path), mHOffset(hOffset), mVOffset(vOffset) { 1265 /* TODO: inherit from DrawBounded and init mLocalBounds */ 1266 } 1267 1268 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1269 renderer.drawTextOnPath(mText, mBytesCount, mCount, mPath, 1270 mHOffset, mVOffset, mPaint); 1271 } 1272 1273 virtual const char* name() override { return "DrawTextOnPath"; } 1274 1275private: 1276 const SkPath* mPath; 1277 float mHOffset; 1278 float mVOffset; 1279}; 1280 1281class DrawPosTextOp : public DrawSomeTextOp { 1282public: 1283 DrawPosTextOp(const char* text, int bytesCount, int count, 1284 const float* positions, const SkPaint* paint) 1285 : DrawSomeTextOp(text, bytesCount, count, paint), mPositions(positions) { 1286 /* TODO: inherit from DrawBounded and init mLocalBounds */ 1287 } 1288 1289 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1290 renderer.drawPosText(mText, mBytesCount, mCount, mPositions, mPaint); 1291 } 1292 1293 virtual const char* name() override { return "DrawPosText"; } 1294 1295private: 1296 const float* mPositions; 1297}; 1298 1299class DrawTextOp : public DrawStrokableOp { 1300public: 1301 DrawTextOp(const char* text, int bytesCount, int count, float x, float y, 1302 const float* positions, const SkPaint* paint, float totalAdvance, const Rect& bounds) 1303 : DrawStrokableOp(bounds, paint), mText(text), mBytesCount(bytesCount), mCount(count), 1304 mX(x), mY(y), mPositions(positions), mTotalAdvance(totalAdvance) { 1305 mPrecacheTransform = SkMatrix::InvalidMatrix(); 1306 } 1307 1308 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 1309 const DeferredDisplayState& state) override { 1310 FontRenderer& fontRenderer = renderer.getCaches().fontRenderer.getFontRenderer(); 1311 SkMatrix transform; 1312 renderer.findBestFontTransform(state.mMatrix, &transform); 1313 if (mPrecacheTransform != transform) { 1314 fontRenderer.precache(mPaint, mText, mCount, transform); 1315 mPrecacheTransform = transform; 1316 } 1317 deferInfo.batchId = mPaint->getColor() == SK_ColorBLACK ? 1318 DeferredDisplayList::kOpBatch_Text : 1319 DeferredDisplayList::kOpBatch_ColorText; 1320 1321 deferInfo.mergeId = reinterpret_cast<mergeid_t>(mPaint->getColor()); 1322 1323 // don't merge decorated text - the decorations won't draw in order 1324 bool hasDecorations = mPaint->getFlags() 1325 & (SkPaint::kUnderlineText_Flag | SkPaint::kStrikeThruText_Flag); 1326 1327 deferInfo.mergeable = state.mMatrix.isPureTranslate() 1328 && !hasDecorations 1329 && PaintUtils::getXfermodeDirect(mPaint) == SkXfermode::kSrcOver_Mode; 1330 } 1331 1332 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1333 Rect bounds; 1334 getLocalBounds(bounds); 1335 renderer.drawText(mText, mBytesCount, mCount, mX, mY, 1336 mPositions, mPaint, mTotalAdvance, bounds); 1337 } 1338 1339 virtual void multiDraw(OpenGLRenderer& renderer, Rect& dirty, 1340 const std::vector<OpStatePair>& ops, const Rect& bounds) override { 1341 for (unsigned int i = 0; i < ops.size(); i++) { 1342 const DeferredDisplayState& state = *(ops[i].state); 1343 DrawOpMode drawOpMode = (i == ops.size() - 1) ? DrawOpMode::kFlush : DrawOpMode::kDefer; 1344 renderer.restoreDisplayState(state, true); // restore all but the clip 1345 1346 DrawTextOp& op = *((DrawTextOp*)ops[i].op); 1347 // quickReject() will not occure in drawText() so we can use mLocalBounds 1348 // directly, we do not need to account for shadow by calling getLocalBounds() 1349 renderer.drawText(op.mText, op.mBytesCount, op.mCount, op.mX, op.mY, 1350 op.mPositions, op.mPaint, op.mTotalAdvance, op.mLocalBounds, 1351 drawOpMode); 1352 } 1353 } 1354 1355 virtual void output(int level, uint32_t logFlags) const override { 1356 OP_LOG("Draw Text of count %d, bytes %d", mCount, mBytesCount); 1357 } 1358 1359 virtual const char* name() override { return "DrawText"; } 1360 1361private: 1362 const char* mText; 1363 int mBytesCount; 1364 int mCount; 1365 float mX; 1366 float mY; 1367 const float* mPositions; 1368 float mTotalAdvance; 1369 SkMatrix mPrecacheTransform; 1370}; 1371 1372/////////////////////////////////////////////////////////////////////////////// 1373// SPECIAL DRAW OPERATIONS 1374/////////////////////////////////////////////////////////////////////////////// 1375 1376class DrawFunctorOp : public DrawOp { 1377public: 1378 DrawFunctorOp(Functor* functor) 1379 : DrawOp(nullptr), mFunctor(functor) {} 1380 1381 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1382 renderer.startMark("GL functor"); 1383 renderer.callDrawGLFunction(mFunctor, dirty); 1384 renderer.endMark(); 1385 } 1386 1387 virtual void output(int level, uint32_t logFlags) const override { 1388 OP_LOG("Draw Functor %p", mFunctor); 1389 } 1390 1391 virtual const char* name() override { return "DrawFunctor"; } 1392 1393private: 1394 Functor* mFunctor; 1395}; 1396 1397class DrawRenderNodeOp : public DrawBoundedOp { 1398 friend class RenderNode; // grant RenderNode access to info of child 1399 friend class DisplayListData; // grant DisplayListData access to info of child 1400 friend class DisplayListCanvas; 1401public: 1402 DrawRenderNodeOp(RenderNode* renderNode, const mat4& transformFromParent, bool clipIsSimple) 1403 : DrawBoundedOp(0, 0, renderNode->getWidth(), renderNode->getHeight(), nullptr) 1404 , renderNode(renderNode) 1405 , mRecordedWithPotentialStencilClip(!clipIsSimple || !transformFromParent.isSimple()) 1406 , mTransformFromParent(transformFromParent) 1407 , mSkipInOrderDraw(false) {} 1408 1409 virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level, 1410 bool useQuickReject) override { 1411 if (renderNode->isRenderable() && !mSkipInOrderDraw) { 1412 renderNode->defer(deferStruct, level + 1); 1413 } 1414 } 1415 1416 virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level, 1417 bool useQuickReject) override { 1418 if (renderNode->isRenderable() && !mSkipInOrderDraw) { 1419 renderNode->replay(replayStruct, level + 1); 1420 } 1421 } 1422 1423 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1424 LOG_ALWAYS_FATAL("should not be called, because replay() is overridden"); 1425 } 1426 1427 virtual void output(int level, uint32_t logFlags) const override { 1428 OP_LOG("Draw RenderNode %p %s", renderNode, renderNode->getName()); 1429 if (renderNode && (logFlags & kOpLogFlag_Recurse)) { 1430 renderNode->output(level + 1); 1431 } 1432 } 1433 1434 virtual const char* name() override { return "DrawRenderNode"; } 1435 1436private: 1437 RenderNode* renderNode; 1438 1439 /** 1440 * This RenderNode was drawn into a DisplayList with the canvas in a state that will likely 1441 * require rendering with stencil clipping. Either: 1442 * 1443 * 1) A path clip or rotated rect clip was in effect on the canvas at record time 1444 * 2) The RenderNode was recorded with a non-simple canvas transform (e.g. rotation) 1445 * 1446 * Note: even if this is false, non-rect clipping may still be applied applied either due to 1447 * property-driven rotation (either in this RenderNode, or any ancestor), or record time 1448 * clipping in an ancestor. These are handled in RenderNode::prepareTreeImpl since they are 1449 * dynamic (relative to a static DisplayList of a parent), and don't affect this flag. 1450 */ 1451 bool mRecordedWithPotentialStencilClip; 1452 1453 /////////////////////////// 1454 // Properties below are used by RenderNode::computeOrderingImpl() and issueOperations() 1455 /////////////////////////// 1456 /** 1457 * Records transform vs parent, used for computing total transform without rerunning DL contents 1458 */ 1459 const mat4 mTransformFromParent; 1460 1461 /** 1462 * Holds the transformation between the projection surface ViewGroup and this RenderNode 1463 * drawing instance. Represents any translations / transformations done within the drawing of 1464 * the compositing ancestor ViewGroup's draw, before the draw of the View represented by this 1465 * DisplayList draw instance. 1466 * 1467 * Note: doesn't include transformation within the RenderNode, or its properties. 1468 */ 1469 mat4 mTransformFromCompositingAncestor; 1470 bool mSkipInOrderDraw; 1471}; 1472 1473/** 1474 * Not a canvas operation, used only by 3d / z ordering logic in RenderNode::iterate() 1475 */ 1476class DrawShadowOp : public DrawOp { 1477public: 1478 DrawShadowOp(const mat4& transformXY, const mat4& transformZ, 1479 float casterAlpha, const SkPath* casterOutline) 1480 : DrawOp(nullptr) 1481 , mTransformXY(transformXY) 1482 , mTransformZ(transformZ) 1483 , mCasterAlpha(casterAlpha) 1484 , mCasterOutline(casterOutline) { 1485 } 1486 1487 virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo, 1488 const DeferredDisplayState& state) override { 1489 renderer.getCaches().tessellationCache.precacheShadows(&state.mMatrix, 1490 renderer.getLocalClipBounds(), isCasterOpaque(), mCasterOutline, 1491 &mTransformXY, &mTransformZ, renderer.getLightCenter(), renderer.getLightRadius()); 1492 } 1493 1494 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1495 TessellationCache::vertexBuffer_pair_t buffers; 1496 Matrix4 drawTransform(*(renderer.currentTransform())); 1497 renderer.getCaches().tessellationCache.getShadowBuffers(&drawTransform, 1498 renderer.getLocalClipBounds(), isCasterOpaque(), mCasterOutline, 1499 &mTransformXY, &mTransformZ, renderer.getLightCenter(), renderer.getLightRadius(), 1500 buffers); 1501 1502 renderer.drawShadow(mCasterAlpha, buffers.first, buffers.second); 1503 } 1504 1505 virtual void output(int level, uint32_t logFlags) const override { 1506 OP_LOGS("DrawShadow"); 1507 } 1508 1509 virtual const char* name() override { return "DrawShadow"; } 1510 1511private: 1512 bool isCasterOpaque() { return mCasterAlpha >= 1.0f; } 1513 1514 const mat4 mTransformXY; 1515 const mat4 mTransformZ; 1516 const float mCasterAlpha; 1517 const SkPath* mCasterOutline; 1518}; 1519 1520class DrawLayerOp : public DrawOp { 1521public: 1522 DrawLayerOp(Layer* layer) 1523 : DrawOp(nullptr), mLayer(layer) {} 1524 1525 virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) override { 1526 renderer.drawLayer(mLayer); 1527 } 1528 1529 virtual void output(int level, uint32_t logFlags) const override { 1530 OP_LOG("Draw Layer %p", mLayer); 1531 } 1532 1533 virtual const char* name() override { return "DrawLayer"; } 1534 1535private: 1536 Layer* mLayer; 1537}; 1538 1539}; // namespace uirenderer 1540}; // namespace android 1541 1542#endif // ANDROID_HWUI_DISPLAY_OPERATION_H 1543