DisplayListRenderer.h revision 9420abd56a2af7ddbeb70562b79d61b2dca8c5a1
1/* 2 * Copyright (C) 2010 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_LIST_RENDERER_H 18#define ANDROID_HWUI_DISPLAY_LIST_RENDERER_H 19 20#include <SkChunkAlloc.h> 21#include <SkFlattenable.h> 22#include <SkMatrix.h> 23#include <SkCamera.h> 24#include <SkPaint.h> 25#include <SkPath.h> 26#include <SkRefCnt.h> 27#include <SkTDArray.h> 28#include <SkTSearch.h> 29 30#include <cutils/compiler.h> 31 32#include "DisplayListLogBuffer.h" 33#include "OpenGLRenderer.h" 34 35namespace android { 36namespace uirenderer { 37 38/////////////////////////////////////////////////////////////////////////////// 39// Defines 40/////////////////////////////////////////////////////////////////////////////// 41 42#define MIN_WRITER_SIZE 4096 43#define OP_MAY_BE_SKIPPED_MASK 0xff000000 44 45// Debug 46#if DEBUG_DISPLAY_LIST 47 #define DISPLAY_LIST_LOGD(...) ALOGD(__VA_ARGS__) 48#else 49 #define DISPLAY_LIST_LOGD(...) 50#endif 51 52// Set to 1 to enable native processing of View properties. 0 by default. Eventually this 53// will go away and we will always use this approach for accelerated apps. 54#define USE_DISPLAY_LIST_PROPERTIES 0 55 56#define TRANSLATION 0x0001 57#define ROTATION 0x0002 58#define ROTATION_3D 0x0004 59#define SCALE 0x0008 60#define PIVOT 0x0010 61 62/////////////////////////////////////////////////////////////////////////////// 63// Display list 64/////////////////////////////////////////////////////////////////////////////// 65 66class DisplayListRenderer; 67 68/** 69 * Replays recorded drawing commands. 70 */ 71class DisplayList { 72public: 73 DisplayList(const DisplayListRenderer& recorder); 74 ANDROID_API ~DisplayList(); 75 76 // IMPORTANT: Update the intialization of OP_NAMES in the .cpp file 77 // when modifying this file 78 enum Op { 79 // Non-drawing operations 80 Save = 0, 81 Restore, 82 RestoreToCount, 83 SaveLayer, 84 SaveLayerAlpha, 85 Translate, 86 Rotate, 87 Scale, 88 Skew, 89 SetMatrix, 90 ConcatMatrix, 91 ClipRect, 92 // Drawing operations 93 DrawDisplayList, 94 DrawLayer, 95 DrawBitmap, 96 DrawBitmapMatrix, 97 DrawBitmapRect, 98 DrawBitmapMesh, 99 DrawPatch, 100 DrawColor, 101 DrawRect, 102 DrawRoundRect, 103 DrawCircle, 104 DrawOval, 105 DrawArc, 106 DrawPath, 107 DrawLines, 108 DrawPoints, 109 DrawText, 110 DrawTextOnPath, 111 DrawPosText, 112 ResetShader, 113 SetupShader, 114 ResetColorFilter, 115 SetupColorFilter, 116 ResetShadow, 117 SetupShadow, 118 ResetPaintFilter, 119 SetupPaintFilter, 120 DrawGLFunction, 121 }; 122 123 // See flags defined in DisplayList.java 124 enum ReplayFlag { 125 kReplayFlag_ClipChildren = 0x1 126 }; 127 128 static const char* OP_NAMES[]; 129 130 void setViewProperties(OpenGLRenderer& renderer, uint32_t width, uint32_t height, 131 uint32_t level); 132 void outputViewProperties(OpenGLRenderer& renderer, char* indent); 133 134 ANDROID_API size_t getSize(); 135 ANDROID_API static void destroyDisplayListDeferred(DisplayList* displayList); 136 ANDROID_API static void outputLogBuffer(int fd); 137 138 void initFromDisplayListRenderer(const DisplayListRenderer& recorder, bool reusing = false); 139 140 status_t replay(OpenGLRenderer& renderer, uint32_t width, uint32_t height, 141 Rect& dirty, int32_t flags, uint32_t level = 0); 142 143 void output(OpenGLRenderer& renderer, uint32_t level = 0); 144 145 void setRenderable(bool renderable) { 146 mIsRenderable = renderable; 147 } 148 149 bool isRenderable() const { 150 return mIsRenderable; 151 } 152 153 void setName(const char* name) { 154 if (name) { 155 mName.setTo(name); 156 } 157 } 158 159 void setClipChildren(bool clipChildren) { 160 mClipChildren = clipChildren; 161 } 162 163 void setStaticMatrix(SkMatrix* matrix) { 164 delete mStaticMatrix; 165 mStaticMatrix = new SkMatrix(*matrix); 166 } 167 168 void setAnimationMatrix(SkMatrix* matrix) { 169 delete mAnimationMatrix; 170 if (matrix) { 171 mAnimationMatrix = new SkMatrix(*matrix); 172 } else { 173 mAnimationMatrix = NULL; 174 } 175 } 176 177 void setAlpha(float alpha) { 178 if (alpha != mAlpha) { 179 mAlpha = alpha; 180 mMultipliedAlpha = (int)(255 * alpha); 181 } 182 } 183 184 void setTranslationX(float translationX) { 185 if (translationX != mTranslationX) { 186 mTranslationX = translationX; 187 mMatrixDirty = true; 188 if (ALMOST_EQUAL(mTranslationX, 0) && ALMOST_EQUAL(mTranslationY, 0)) { 189 mMatrixFlags &= ~TRANSLATION; 190 } else { 191 mMatrixFlags |= TRANSLATION; 192 } 193 } 194 } 195 196 void setTranslationY(float translationY) { 197 if (translationY != mTranslationY) { 198 mTranslationY = translationY; 199 mMatrixDirty = true; 200 if (ALMOST_EQUAL(mTranslationX, 0) && ALMOST_EQUAL(mTranslationY, 0)) { 201 mMatrixFlags &= ~TRANSLATION; 202 } else { 203 mMatrixFlags |= TRANSLATION; 204 } 205 } 206 } 207 208 void setRotation(float rotation) { 209 if (rotation != mRotation) { 210 mRotation = rotation; 211 mMatrixDirty = true; 212 if (ALMOST_EQUAL(mRotation, 0)) { 213 mMatrixFlags &= ~ROTATION; 214 } else { 215 mMatrixFlags |= ROTATION; 216 } 217 } 218 } 219 220 void setRotationX(float rotationX) { 221 if (rotationX != mRotationX) { 222 mRotationX = rotationX; 223 mMatrixDirty = true; 224 if (ALMOST_EQUAL(mRotationX, 0) && ALMOST_EQUAL(mRotationY, 0)) { 225 mMatrixFlags &= ~ROTATION_3D; 226 } else { 227 mMatrixFlags |= ROTATION_3D; 228 } 229 } 230 } 231 232 void setRotationY(float rotationY) { 233 if (rotationY != mRotationY) { 234 mRotationY = rotationY; 235 mMatrixDirty = true; 236 if (ALMOST_EQUAL(mRotationX, 0) && ALMOST_EQUAL(mRotationY, 0)) { 237 mMatrixFlags &= ~ROTATION_3D; 238 } else { 239 mMatrixFlags |= ROTATION_3D; 240 } 241 } 242 } 243 244 void setScaleX(float scaleX) { 245 if (scaleX != mScaleX) { 246 mScaleX = scaleX; 247 mMatrixDirty = true; 248 if (ALMOST_EQUAL(mScaleX, 1) && ALMOST_EQUAL(mScaleY, 1)) { 249 mMatrixFlags &= ~SCALE; 250 } else { 251 mMatrixFlags |= SCALE; 252 } 253 } 254 } 255 256 void setScaleY(float scaleY) { 257 if (scaleY != mScaleY) { 258 mScaleY = scaleY; 259 mMatrixDirty = true; 260 if (ALMOST_EQUAL(mScaleX, 1) && ALMOST_EQUAL(mScaleY, 1)) { 261 mMatrixFlags &= ~SCALE; 262 } else { 263 mMatrixFlags |= SCALE; 264 } 265 } 266 } 267 268 void setPivotX(float pivotX) { 269 mPivotX = pivotX; 270 mMatrixDirty = true; 271 if (ALMOST_EQUAL(mPivotX, 0) && ALMOST_EQUAL(mPivotY, 0)) { 272 mMatrixFlags &= ~PIVOT; 273 } else { 274 mMatrixFlags |= PIVOT; 275 } 276 mPivotExplicitlySet = true; 277 } 278 279 void setPivotY(float pivotY) { 280 mPivotY = pivotY; 281 mMatrixDirty = true; 282 if (ALMOST_EQUAL(mPivotX, 0) && ALMOST_EQUAL(mPivotY, 0)) { 283 mMatrixFlags &= ~PIVOT; 284 } else { 285 mMatrixFlags |= PIVOT; 286 } 287 mPivotExplicitlySet = true; 288 } 289 290 void setCameraDistance(float distance) { 291 if (distance != mCameraDistance) { 292 mCameraDistance = distance; 293 mMatrixDirty = true; 294 if (!mTransformCamera) { 295 mTransformCamera = new Sk3DView(); 296 mTransformMatrix3D = new SkMatrix(); 297 } 298 mTransformCamera->setCameraLocation(0, 0, distance); 299 } 300 } 301 302 void setLeft(int left) { 303 if (left != mLeft) { 304 mLeft = left; 305 mWidth = mRight - mLeft; 306 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 307 mMatrixDirty = true; 308 } 309 } 310 } 311 312 void setTop(int top) { 313 if (top != mTop) { 314 mTop = top; 315 mHeight = mBottom - mTop; 316 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 317 mMatrixDirty = true; 318 } 319 } 320 } 321 322 void setRight(int right) { 323 if (right != mRight) { 324 mRight = right; 325 mWidth = mRight - mLeft; 326 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 327 mMatrixDirty = true; 328 } 329 } 330 } 331 332 void setBottom(int bottom) { 333 if (bottom != mBottom) { 334 mBottom = bottom; 335 mHeight = mBottom - mTop; 336 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 337 mMatrixDirty = true; 338 } 339 } 340 } 341 342 void setLeftTop(int left, int top) { 343 if (left != mLeft || top != mTop) { 344 mLeft = left; 345 mTop = top; 346 mWidth = mRight - mLeft; 347 mHeight = mBottom - mTop; 348 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 349 mMatrixDirty = true; 350 } 351 } 352 } 353 354 void setLeftTopRightBottom(int left, int top, int right, int bottom) { 355 if (left != mLeft || top != mTop || right != mRight || bottom != mBottom) { 356 mLeft = left; 357 mTop = top; 358 mRight = right; 359 mBottom = bottom; 360 mWidth = mRight - mLeft; 361 mHeight = mBottom - mTop; 362 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 363 mMatrixDirty = true; 364 } 365 } 366 } 367 368 void offsetLeftRight(int offset) { 369 if (offset != 0) { 370 mLeft += offset; 371 mRight += offset; 372 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 373 mMatrixDirty = true; 374 } 375 } 376 } 377 378 void offsetTopBottom(int offset) { 379 if (offset != 0) { 380 mTop += offset; 381 mBottom += offset; 382 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 383 mMatrixDirty = true; 384 } 385 } 386 } 387 388 void setCaching(bool caching) { 389 mCaching = caching; 390 } 391 392private: 393 void init(); 394 395 void initProperties(); 396 397 void clearResources(); 398 399 void updateMatrix(); 400 401 class TextContainer { 402 public: 403 size_t length() const { 404 return mByteLength; 405 } 406 407 const char* text() const { 408 return (const char*) mText; 409 } 410 411 size_t mByteLength; 412 const char* mText; 413 }; 414 415 SkBitmap* getBitmap() { 416 return (SkBitmap*) getInt(); 417 } 418 419 SkiaShader* getShader() { 420 return (SkiaShader*) getInt(); 421 } 422 423 SkiaColorFilter* getColorFilter() { 424 return (SkiaColorFilter*) getInt(); 425 } 426 427 inline int32_t getIndex() { 428 return mReader.readInt(); 429 } 430 431 inline int32_t getInt() { 432 return mReader.readInt(); 433 } 434 435 inline uint32_t getUInt() { 436 return mReader.readU32(); 437 } 438 439 SkMatrix* getMatrix() { 440 return (SkMatrix*) getInt(); 441 } 442 443 SkPath* getPath() { 444 return (SkPath*) getInt(); 445 } 446 447 SkPaint* getPaint(OpenGLRenderer& renderer) { 448 return renderer.filterPaint((SkPaint*) getInt()); 449 } 450 451 DisplayList* getDisplayList() { 452 return (DisplayList*) getInt(); 453 } 454 455 inline float getFloat() { 456 return mReader.readScalar(); 457 } 458 459 int32_t* getInts(uint32_t& count) { 460 count = getInt(); 461 return (int32_t*) mReader.skip(count * sizeof(int32_t)); 462 } 463 464 uint32_t* getUInts(int8_t& count) { 465 count = getInt(); 466 return (uint32_t*) mReader.skip(count * sizeof(uint32_t)); 467 } 468 469 float* getFloats(int32_t& count) { 470 count = getInt(); 471 return (float*) mReader.skip(count * sizeof(float)); 472 } 473 474 void getText(TextContainer* text) { 475 size_t length = text->mByteLength = getInt(); 476 text->mText = (const char*) mReader.skip(length); 477 } 478 479 Vector<SkBitmap*> mBitmapResources; 480 Vector<SkiaColorFilter*> mFilterResources; 481 482 Vector<SkPaint*> mPaints; 483 Vector<SkPath*> mPaths; 484 Vector<SkMatrix*> mMatrices; 485 Vector<SkiaShader*> mShaders; 486 487 mutable SkFlattenableReadBuffer mReader; 488 489 size_t mSize; 490 491 bool mIsRenderable; 492 493 String8 mName; 494 495 // View properties 496 bool mClipChildren; 497 float mAlpha; 498 int mMultipliedAlpha; 499 float mTranslationX, mTranslationY; 500 float mRotation, mRotationX, mRotationY; 501 float mScaleX, mScaleY; 502 float mPivotX, mPivotY; 503 float mCameraDistance; 504 int mLeft, mTop, mRight, mBottom; 505 int mWidth, mHeight; 506 int mPrevWidth, mPrevHeight; 507 bool mPivotExplicitlySet; 508 bool mMatrixDirty; 509 bool mMatrixIsIdentity; 510 uint32_t mMatrixFlags; 511 SkMatrix* mTransformMatrix; 512 Sk3DView* mTransformCamera; 513 SkMatrix* mTransformMatrix3D; 514 SkMatrix* mStaticMatrix; 515 SkMatrix* mAnimationMatrix; 516 bool mCaching; 517}; 518 519/////////////////////////////////////////////////////////////////////////////// 520// Renderer 521/////////////////////////////////////////////////////////////////////////////// 522 523/** 524 * Records drawing commands in a display list for latter playback. 525 */ 526class DisplayListRenderer: public OpenGLRenderer { 527public: 528 ANDROID_API DisplayListRenderer(); 529 virtual ~DisplayListRenderer(); 530 531 ANDROID_API DisplayList* getDisplayList(DisplayList* displayList); 532 533 virtual void setViewport(int width, int height); 534 virtual void prepareDirty(float left, float top, float right, float bottom, bool opaque); 535 virtual void finish(); 536 537 virtual status_t callDrawGLFunction(Functor *functor, Rect& dirty); 538 539 virtual void interrupt(); 540 virtual void resume(); 541 542 virtual int save(int flags); 543 virtual void restore(); 544 virtual void restoreToCount(int saveCount); 545 546 virtual int saveLayer(float left, float top, float right, float bottom, 547 SkPaint* p, int flags); 548 virtual int saveLayerAlpha(float left, float top, float right, float bottom, 549 int alpha, int flags); 550 551 virtual void translate(float dx, float dy); 552 virtual void rotate(float degrees); 553 virtual void scale(float sx, float sy); 554 virtual void skew(float sx, float sy); 555 556 virtual void setMatrix(SkMatrix* matrix); 557 virtual void concatMatrix(SkMatrix* matrix); 558 559 virtual bool clipRect(float left, float top, float right, float bottom, SkRegion::Op op); 560 561 virtual status_t drawDisplayList(DisplayList* displayList, uint32_t width, uint32_t height, 562 Rect& dirty, int32_t flags, uint32_t level = 0); 563 virtual void drawLayer(Layer* layer, float x, float y, SkPaint* paint); 564 virtual void drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint); 565 virtual void drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint); 566 virtual void drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop, 567 float srcRight, float srcBottom, float dstLeft, float dstTop, 568 float dstRight, float dstBottom, SkPaint* paint); 569 virtual void drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight, 570 float* vertices, int* colors, SkPaint* paint); 571 virtual void drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs, 572 const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors, 573 float left, float top, float right, float bottom, SkPaint* paint); 574 virtual void drawColor(int color, SkXfermode::Mode mode); 575 virtual void drawRect(float left, float top, float right, float bottom, SkPaint* paint); 576 virtual void drawRoundRect(float left, float top, float right, float bottom, 577 float rx, float ry, SkPaint* paint); 578 virtual void drawCircle(float x, float y, float radius, SkPaint* paint); 579 virtual void drawOval(float left, float top, float right, float bottom, SkPaint* paint); 580 virtual void drawArc(float left, float top, float right, float bottom, 581 float startAngle, float sweepAngle, bool useCenter, SkPaint* paint); 582 virtual void drawPath(SkPath* path, SkPaint* paint); 583 virtual void drawLines(float* points, int count, SkPaint* paint); 584 virtual void drawPoints(float* points, int count, SkPaint* paint); 585 virtual void drawText(const char* text, int bytesCount, int count, float x, float y, 586 SkPaint* paint, float length = -1.0f); 587 virtual void drawTextOnPath(const char* text, int bytesCount, int count, SkPath* path, 588 float hOffset, float vOffset, SkPaint* paint); 589 virtual void drawPosText(const char* text, int bytesCount, int count, const float* positions, 590 SkPaint* paint); 591 592 virtual void resetShader(); 593 virtual void setupShader(SkiaShader* shader); 594 595 virtual void resetColorFilter(); 596 virtual void setupColorFilter(SkiaColorFilter* filter); 597 598 virtual void resetShadow(); 599 virtual void setupShadow(float radius, float dx, float dy, int color); 600 601 virtual void resetPaintFilter(); 602 virtual void setupPaintFilter(int clearBits, int setBits); 603 604 ANDROID_API void reset(); 605 606 const SkWriter32& writeStream() const { 607 return mWriter; 608 } 609 610 const Vector<SkBitmap*>& getBitmapResources() const { 611 return mBitmapResources; 612 } 613 614 const Vector<SkiaColorFilter*>& getFilterResources() const { 615 return mFilterResources; 616 } 617 618 const Vector<SkiaShader*>& getShaders() const { 619 return mShaders; 620 } 621 622 const Vector<SkPaint*>& getPaints() const { 623 return mPaints; 624 } 625 626 const Vector<SkPath*>& getPaths() const { 627 return mPaths; 628 } 629 630 const Vector<SkMatrix*>& getMatrices() const { 631 return mMatrices; 632 } 633 634private: 635 void insertRestoreToCount() { 636 if (mRestoreSaveCount >= 0) { 637 mWriter.writeInt(DisplayList::RestoreToCount); 638 addInt(mRestoreSaveCount); 639 mRestoreSaveCount = -1; 640 } 641 } 642 643 void insertTranlate() { 644 if (mHasTranslate) { 645 if (mTranslateX != 0.0f || mTranslateY != 0.0f) { 646 mWriter.writeInt(DisplayList::Translate); 647 addPoint(mTranslateX, mTranslateY); 648 mTranslateX = mTranslateY = 0.0f; 649 } 650 mHasTranslate = false; 651 } 652 } 653 654 inline void addOp(const DisplayList::Op drawOp) { 655 insertRestoreToCount(); 656 insertTranlate(); 657 mWriter.writeInt(drawOp); 658 mHasDrawOps = mHasDrawOps || drawOp >= DisplayList::DrawDisplayList; 659 } 660 661 uint32_t* addOp(const DisplayList::Op drawOp, const bool reject) { 662 insertRestoreToCount(); 663 insertTranlate(); 664 mHasDrawOps = mHasDrawOps || drawOp >= DisplayList::DrawDisplayList; 665 if (reject) { 666 mWriter.writeInt(OP_MAY_BE_SKIPPED_MASK | drawOp); 667 mWriter.writeInt(0xdeaddead); 668 mBufferSize = mWriter.size(); 669 return mWriter.peek32(mBufferSize - sizeof(int32_t)); 670 } 671 mWriter.writeInt(drawOp); 672 return NULL; 673 } 674 675 inline void addSkip(uint32_t* location) { 676 if (location) { 677 *location = (int32_t) (mWriter.size() - mBufferSize); 678 } 679 } 680 681 inline void addInt(int32_t value) { 682 mWriter.writeInt(value); 683 } 684 685 inline void addSize(uint32_t w, uint32_t h) { 686 mWriter.writeInt(w); 687 mWriter.writeInt(h); 688 } 689 690 void addInts(const int32_t* values, uint32_t count) { 691 mWriter.writeInt(count); 692 for (uint32_t i = 0; i < count; i++) { 693 mWriter.writeInt(values[i]); 694 } 695 } 696 697 void addUInts(const uint32_t* values, int8_t count) { 698 mWriter.writeInt(count); 699 for (int8_t i = 0; i < count; i++) { 700 mWriter.writeInt(values[i]); 701 } 702 } 703 704 inline void addFloat(float value) { 705 mWriter.writeScalar(value); 706 } 707 708 void addFloats(const float* values, int32_t count) { 709 mWriter.writeInt(count); 710 for (int32_t i = 0; i < count; i++) { 711 mWriter.writeScalar(values[i]); 712 } 713 } 714 715 inline void addPoint(float x, float y) { 716 mWriter.writeScalar(x); 717 mWriter.writeScalar(y); 718 } 719 720 inline void addBounds(float left, float top, float right, float bottom) { 721 mWriter.writeScalar(left); 722 mWriter.writeScalar(top); 723 mWriter.writeScalar(right); 724 mWriter.writeScalar(bottom); 725 } 726 727 inline void addText(const void* text, size_t byteLength) { 728 mWriter.writeInt(byteLength); 729 mWriter.writePad(text, byteLength); 730 } 731 732 inline void addPath(SkPath* path) { 733 if (!path) { 734 addInt((int) NULL); 735 return; 736 } 737 738 SkPath* pathCopy = mPathMap.valueFor(path); 739 if (pathCopy == NULL || pathCopy->getGenerationID() != path->getGenerationID()) { 740 pathCopy = new SkPath(*path); 741 pathCopy->setSourcePath(path); 742 // replaceValueFor() performs an add if the entry doesn't exist 743 mPathMap.replaceValueFor(path, pathCopy); 744 mPaths.add(pathCopy); 745 } 746 747 addInt((int) pathCopy); 748 } 749 750 inline void addPaint(SkPaint* paint) { 751 if (!paint) { 752 addInt((int) NULL); 753 return; 754 } 755 756 SkPaint* paintCopy = mPaintMap.valueFor(paint); 757 if (paintCopy == NULL || paintCopy->getGenerationID() != paint->getGenerationID()) { 758 paintCopy = new SkPaint(*paint); 759 // replaceValueFor() performs an add if the entry doesn't exist 760 mPaintMap.replaceValueFor(paint, paintCopy); 761 mPaints.add(paintCopy); 762 } 763 764 addInt((int) paintCopy); 765 } 766 767 inline void addDisplayList(DisplayList* displayList) { 768 // TODO: To be safe, the display list should be ref-counted in the 769 // resources cache, but we rely on the caller (UI toolkit) to 770 // do the right thing for now 771 addInt((int) displayList); 772 } 773 774 inline void addMatrix(SkMatrix* matrix) { 775 // Copying the matrix is cheap and prevents against the user changing the original 776 // matrix before the operation that uses it 777 SkMatrix* copy = new SkMatrix(*matrix); 778 addInt((int) copy); 779 mMatrices.add(copy); 780 } 781 782 inline void addBitmap(SkBitmap* bitmap) { 783 // Note that this assumes the bitmap is immutable. There are cases this won't handle 784 // correctly, such as creating the bitmap from scratch, drawing with it, changing its 785 // contents, and drawing again. The only fix would be to always copy it the first time, 786 // which doesn't seem worth the extra cycles for this unlikely case. 787 addInt((int) bitmap); 788 mBitmapResources.add(bitmap); 789 Caches::getInstance().resourceCache.incrementRefcount(bitmap); 790 } 791 792 inline void addShader(SkiaShader* shader) { 793 if (!shader) { 794 addInt((int) NULL); 795 return; 796 } 797 798 SkiaShader* shaderCopy = mShaderMap.valueFor(shader); 799 // TODO: We also need to handle generation ID changes in compose shaders 800 if (shaderCopy == NULL || shaderCopy->getGenerationId() != shader->getGenerationId()) { 801 shaderCopy = shader->copy(); 802 // replaceValueFor() performs an add if the entry doesn't exist 803 mShaderMap.replaceValueFor(shader, shaderCopy); 804 mShaders.add(shaderCopy); 805 Caches::getInstance().resourceCache.incrementRefcount(shaderCopy); 806 } 807 808 addInt((int) shaderCopy); 809 } 810 811 inline void addColorFilter(SkiaColorFilter* colorFilter) { 812 addInt((int) colorFilter); 813 mFilterResources.add(colorFilter); 814 Caches::getInstance().resourceCache.incrementRefcount(colorFilter); 815 } 816 817 Vector<SkBitmap*> mBitmapResources; 818 Vector<SkiaColorFilter*> mFilterResources; 819 820 Vector<SkPaint*> mPaints; 821 DefaultKeyedVector<SkPaint*, SkPaint*> mPaintMap; 822 823 Vector<SkPath*> mPaths; 824 DefaultKeyedVector<SkPath*, SkPath*> mPathMap; 825 826 Vector<SkiaShader*> mShaders; 827 DefaultKeyedVector<SkiaShader*, SkiaShader*> mShaderMap; 828 829 Vector<SkMatrix*> mMatrices; 830 831 SkWriter32 mWriter; 832 uint32_t mBufferSize; 833 834 int mRestoreSaveCount; 835 836 float mTranslateX; 837 float mTranslateY; 838 bool mHasTranslate; 839 840 bool mHasDrawOps; 841 842 friend class DisplayList; 843 844}; // class DisplayListRenderer 845 846}; // namespace uirenderer 847}; // namespace android 848 849#endif // ANDROID_HWUI_DISPLAY_LIST_RENDERER_H 850