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