DisplayListRenderer.h revision 390f882f8905e8d1ac0d4b7f2e01aa04dccc3c16
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 bool 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 setApplicationScale(float scale) { 160 mApplicationScale = scale; 161 } 162 163 void setClipChildren(bool clipChildren) { 164 mClipChildren = clipChildren; 165 } 166 167 void setAlpha(float alpha) { 168 if (alpha != mAlpha) { 169 mAlpha = alpha; 170 mMultipliedAlpha = (int)(255 * alpha); 171 } 172 } 173 174 void setTranslationX(float translationX) { 175 if (translationX != mTranslationX) { 176 mTranslationX = translationX; 177 mMatrixDirty = true; 178 if (ALMOST_EQUAL(mTranslationX, 0) && ALMOST_EQUAL(mTranslationY, 0)) { 179 mMatrixFlags &= ~TRANSLATION; 180 } else { 181 mMatrixFlags |= TRANSLATION; 182 } 183 } 184 } 185 186 void setTranslationY(float translationY) { 187 if (translationY != mTranslationY) { 188 mTranslationY = translationY; 189 mMatrixDirty = true; 190 if (ALMOST_EQUAL(mTranslationX, 0) && ALMOST_EQUAL(mTranslationY, 0)) { 191 mMatrixFlags &= ~TRANSLATION; 192 } else { 193 mMatrixFlags |= TRANSLATION; 194 } 195 } 196 } 197 198 void setRotation(float rotation) { 199 if (rotation != mRotation) { 200 mRotation = rotation; 201 mMatrixDirty = true; 202 if (ALMOST_EQUAL(mRotation, 0)) { 203 mMatrixFlags &= ~ROTATION; 204 } else { 205 mMatrixFlags |= ROTATION; 206 } 207 } 208 } 209 210 void setRotationX(float rotationX) { 211 if (rotationX != mRotationX) { 212 mRotationX = rotationX; 213 mMatrixDirty = true; 214 if (ALMOST_EQUAL(mRotationX, 0) && ALMOST_EQUAL(mRotationY, 0)) { 215 mMatrixFlags &= ~ROTATION_3D; 216 } else { 217 mMatrixFlags |= ROTATION_3D; 218 } 219 } 220 } 221 222 void setRotationY(float rotationY) { 223 if (rotationY != mRotationY) { 224 mRotationY = rotationY; 225 mMatrixDirty = true; 226 if (ALMOST_EQUAL(mRotationX, 0) && ALMOST_EQUAL(mRotationY, 0)) { 227 mMatrixFlags &= ~ROTATION_3D; 228 } else { 229 mMatrixFlags |= ROTATION_3D; 230 } 231 } 232 } 233 234 void setScaleX(float scaleX) { 235 if (scaleX != mScaleX) { 236 mScaleX = scaleX; 237 mMatrixDirty = true; 238 if (ALMOST_EQUAL(mScaleX, 1) && ALMOST_EQUAL(mScaleY, 1)) { 239 mMatrixFlags &= ~SCALE; 240 } else { 241 mMatrixFlags |= SCALE; 242 } 243 } 244 } 245 246 void setScaleY(float scaleY) { 247 if (scaleY != mScaleY) { 248 mScaleY = scaleY; 249 mMatrixDirty = true; 250 if (ALMOST_EQUAL(mScaleX, 1) && ALMOST_EQUAL(mScaleY, 1)) { 251 mMatrixFlags &= ~SCALE; 252 } else { 253 mMatrixFlags |= SCALE; 254 } 255 } 256 } 257 258 void setPivotX(float pivotX) { 259 mPivotX = pivotX; 260 mMatrixDirty = true; 261 if (ALMOST_EQUAL(mPivotX, 0) && ALMOST_EQUAL(mPivotY, 0)) { 262 mMatrixFlags &= ~PIVOT; 263 } else { 264 mMatrixFlags |= PIVOT; 265 } 266 mPivotExplicitlySet = true; 267 } 268 269 void setPivotY(float pivotY) { 270 mPivotY = pivotY; 271 mMatrixDirty = true; 272 if (ALMOST_EQUAL(mPivotX, 0) && ALMOST_EQUAL(mPivotY, 0)) { 273 mMatrixFlags &= ~PIVOT; 274 } else { 275 mMatrixFlags |= PIVOT; 276 } 277 mPivotExplicitlySet = true; 278 } 279 280 void setCameraDistance(float distance) { 281 if (distance != mCameraDistance) { 282 mCameraDistance = distance; 283 mMatrixDirty = true; 284 if (!mTransformCamera) { 285 mTransformCamera = new Sk3DView(); 286 mTransformMatrix3D = new SkMatrix(); 287 } 288 mTransformCamera->setCameraLocation(0, 0, distance); 289 } 290 } 291 292 void setLeft(int left) { 293 if (left != mLeft) { 294 mLeft = left; 295 mWidth = mRight - mLeft; 296 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 297 mMatrixDirty = true; 298 } 299 } 300 } 301 302 void setTop(int top) { 303 if (top != mTop) { 304 mTop = top; 305 mHeight = mBottom - mTop; 306 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 307 mMatrixDirty = true; 308 } 309 } 310 } 311 312 void setRight(int right) { 313 if (right != mRight) { 314 mRight = right; 315 mWidth = mRight - mLeft; 316 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 317 mMatrixDirty = true; 318 } 319 } 320 } 321 322 void setBottom(int bottom) { 323 if (bottom != mBottom) { 324 mBottom = bottom; 325 mHeight = mBottom - mTop; 326 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 327 mMatrixDirty = true; 328 } 329 } 330 } 331 332 void setLeftTop(int left, int top) { 333 if (left != mLeft || top != mTop) { 334 mLeft = left; 335 mTop = top; 336 mWidth = mRight - mLeft; 337 mHeight = mBottom - mTop; 338 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 339 mMatrixDirty = true; 340 } 341 } 342 } 343 344 void setLeftTopRightBottom(int left, int top, int right, int bottom) { 345 if (left != mLeft || top != mTop || right != mRight || bottom != mBottom) { 346 mLeft = left; 347 mTop = top; 348 mRight = right; 349 mBottom = bottom; 350 mWidth = mRight - mLeft; 351 mHeight = mBottom - mTop; 352 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 353 mMatrixDirty = true; 354 } 355 } 356 } 357 358 void offsetLeftRight(int offset) { 359 if (offset != 0) { 360 mLeft += offset; 361 mRight += offset; 362 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 363 mMatrixDirty = true; 364 } 365 } 366 } 367 368 void offsetTopBottom(int offset) { 369 if (offset != 0) { 370 mTop += offset; 371 mBottom += offset; 372 if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) { 373 mMatrixDirty = true; 374 } 375 } 376 } 377 378 void setCaching(bool caching) { 379 mCaching = caching; 380 } 381 382 void transformRect(float left, float top, float right, float bottom, Rect& result); 383 384private: 385 void init(); 386 387 void initProperties(); 388 389 void clearResources(); 390 391 void updateMatrix(); 392 393 class TextContainer { 394 public: 395 size_t length() const { 396 return mByteLength; 397 } 398 399 const char* text() const { 400 return (const char*) mText; 401 } 402 403 size_t mByteLength; 404 const char* mText; 405 }; 406 407 SkBitmap* getBitmap() { 408 return (SkBitmap*) getInt(); 409 } 410 411 SkiaShader* getShader() { 412 return (SkiaShader*) getInt(); 413 } 414 415 SkiaColorFilter* getColorFilter() { 416 return (SkiaColorFilter*) getInt(); 417 } 418 419 inline int32_t getIndex() { 420 return mReader.readInt(); 421 } 422 423 inline int32_t getInt() { 424 return mReader.readInt(); 425 } 426 427 inline uint32_t getUInt() { 428 return mReader.readU32(); 429 } 430 431 SkMatrix* getMatrix() { 432 return (SkMatrix*) getInt(); 433 } 434 435 SkPath* getPath() { 436 return (SkPath*) getInt(); 437 } 438 439 SkPaint* getPaint(OpenGLRenderer& renderer) { 440 return renderer.filterPaint((SkPaint*) getInt()); 441 } 442 443 DisplayList* getDisplayList() { 444 return (DisplayList*) getInt(); 445 } 446 447 inline float getFloat() { 448 return mReader.readScalar(); 449 } 450 451 int32_t* getInts(uint32_t& count) { 452 count = getInt(); 453 return (int32_t*) mReader.skip(count * sizeof(int32_t)); 454 } 455 456 uint32_t* getUInts(int8_t& count) { 457 count = getInt(); 458 return (uint32_t*) mReader.skip(count * sizeof(uint32_t)); 459 } 460 461 float* getFloats(int32_t& count) { 462 count = getInt(); 463 return (float*) mReader.skip(count * sizeof(float)); 464 } 465 466 void getText(TextContainer* text) { 467 size_t length = text->mByteLength = getInt(); 468 text->mText = (const char*) mReader.skip(length); 469 } 470 471 Vector<SkBitmap*> mBitmapResources; 472 Vector<SkiaColorFilter*> mFilterResources; 473 474 Vector<SkPaint*> mPaints; 475 Vector<SkPath*> mPaths; 476 Vector<SkMatrix*> mMatrices; 477 Vector<SkiaShader*> mShaders; 478 479 mutable SkFlattenableReadBuffer mReader; 480 481 size_t mSize; 482 483 bool mIsRenderable; 484 485 String8 mName; 486 487 // View properties 488 float mApplicationScale; 489 bool mClipChildren; 490 float mAlpha; 491 int mMultipliedAlpha; 492 float mTranslationX, mTranslationY; 493 float mRotation, mRotationX, mRotationY; 494 float mScaleX, mScaleY; 495 float mPivotX, mPivotY; 496 float mCameraDistance; 497 int mLeft, mTop, mRight, mBottom; 498 int mWidth, mHeight; 499 int mPrevWidth, mPrevHeight; 500 bool mPivotExplicitlySet; 501 bool mMatrixDirty; 502 bool mMatrixIsIdentity; 503 uint32_t mMatrixFlags; 504 SkMatrix* mTransformMatrix; 505 Sk3DView* mTransformCamera; 506 SkMatrix* mTransformMatrix3D; 507 bool mCaching; 508}; 509 510/////////////////////////////////////////////////////////////////////////////// 511// Renderer 512/////////////////////////////////////////////////////////////////////////////// 513 514/** 515 * Records drawing commands in a display list for latter playback. 516 */ 517class DisplayListRenderer: public OpenGLRenderer { 518public: 519 ANDROID_API DisplayListRenderer(); 520 virtual ~DisplayListRenderer(); 521 522 ANDROID_API DisplayList* getDisplayList(DisplayList* displayList); 523 524 virtual void setViewport(int width, int height); 525 virtual void prepareDirty(float left, float top, float right, float bottom, bool opaque); 526 virtual void finish(); 527 528 virtual bool callDrawGLFunction(Functor *functor, Rect& dirty); 529 530 virtual void interrupt(); 531 virtual void resume(); 532 533 virtual int save(int flags); 534 virtual void restore(); 535 virtual void restoreToCount(int saveCount); 536 537 virtual int saveLayer(float left, float top, float right, float bottom, 538 SkPaint* p, int flags); 539 virtual int saveLayerAlpha(float left, float top, float right, float bottom, 540 int alpha, int flags); 541 542 virtual void translate(float dx, float dy); 543 virtual void rotate(float degrees); 544 virtual void scale(float sx, float sy); 545 virtual void skew(float sx, float sy); 546 547 virtual void setMatrix(SkMatrix* matrix); 548 virtual void concatMatrix(SkMatrix* matrix); 549 550 virtual bool clipRect(float left, float top, float right, float bottom, SkRegion::Op op); 551 552 virtual bool drawDisplayList(DisplayList* displayList, uint32_t width, uint32_t height, 553 Rect& dirty, int32_t flags, uint32_t level = 0); 554 virtual void drawLayer(Layer* layer, float x, float y, SkPaint* paint); 555 virtual void drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint); 556 virtual void drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint); 557 virtual void drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop, 558 float srcRight, float srcBottom, float dstLeft, float dstTop, 559 float dstRight, float dstBottom, SkPaint* paint); 560 virtual void drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight, 561 float* vertices, int* colors, SkPaint* paint); 562 virtual void drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs, 563 const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors, 564 float left, float top, float right, float bottom, SkPaint* paint); 565 virtual void drawColor(int color, SkXfermode::Mode mode); 566 virtual void drawRect(float left, float top, float right, float bottom, SkPaint* paint); 567 virtual void drawRoundRect(float left, float top, float right, float bottom, 568 float rx, float ry, SkPaint* paint); 569 virtual void drawCircle(float x, float y, float radius, SkPaint* paint); 570 virtual void drawOval(float left, float top, float right, float bottom, SkPaint* paint); 571 virtual void drawArc(float left, float top, float right, float bottom, 572 float startAngle, float sweepAngle, bool useCenter, SkPaint* paint); 573 virtual void drawPath(SkPath* path, SkPaint* paint); 574 virtual void drawLines(float* points, int count, SkPaint* paint); 575 virtual void drawPoints(float* points, int count, SkPaint* paint); 576 virtual void drawText(const char* text, int bytesCount, int count, float x, float y, 577 SkPaint* paint, float length = 1.0f); 578 virtual void drawTextOnPath(const char* text, int bytesCount, int count, SkPath* path, 579 float hOffset, float vOffset, SkPaint* paint); 580 virtual void drawPosText(const char* text, int bytesCount, int count, const float* positions, 581 SkPaint* paint); 582 583 virtual void resetShader(); 584 virtual void setupShader(SkiaShader* shader); 585 586 virtual void resetColorFilter(); 587 virtual void setupColorFilter(SkiaColorFilter* filter); 588 589 virtual void resetShadow(); 590 virtual void setupShadow(float radius, float dx, float dy, int color); 591 592 virtual void resetPaintFilter(); 593 virtual void setupPaintFilter(int clearBits, int setBits); 594 595 ANDROID_API void reset(); 596 597 const SkWriter32& writeStream() const { 598 return mWriter; 599 } 600 601 const Vector<SkBitmap*>& getBitmapResources() const { 602 return mBitmapResources; 603 } 604 605 const Vector<SkiaColorFilter*>& getFilterResources() const { 606 return mFilterResources; 607 } 608 609 const Vector<SkiaShader*>& getShaders() const { 610 return mShaders; 611 } 612 613 const Vector<SkPaint*>& getPaints() const { 614 return mPaints; 615 } 616 617 const Vector<SkPath*>& getPaths() const { 618 return mPaths; 619 } 620 621 const Vector<SkMatrix*>& getMatrices() const { 622 return mMatrices; 623 } 624 625private: 626 void insertRestoreToCount() { 627 if (mRestoreSaveCount >= 0) { 628 mWriter.writeInt(DisplayList::RestoreToCount); 629 addInt(mRestoreSaveCount); 630 mRestoreSaveCount = -1; 631 } 632 } 633 634 void insertTranlate() { 635 if (mHasTranslate) { 636 if (mTranslateX != 0.0f || mTranslateY != 0.0f) { 637 mWriter.writeInt(DisplayList::Translate); 638 addPoint(mTranslateX, mTranslateY); 639 mTranslateX = mTranslateY = 0.0f; 640 } 641 mHasTranslate = false; 642 } 643 } 644 645 inline void addOp(const DisplayList::Op drawOp) { 646 insertRestoreToCount(); 647 insertTranlate(); 648 mWriter.writeInt(drawOp); 649 mHasDrawOps = mHasDrawOps || drawOp >= DisplayList::DrawDisplayList; 650 } 651 652 uint32_t* addOp(const DisplayList::Op drawOp, const bool reject) { 653 insertRestoreToCount(); 654 insertTranlate(); 655 mHasDrawOps = mHasDrawOps || drawOp >= DisplayList::DrawDisplayList; 656 if (reject) { 657 mWriter.writeInt(OP_MAY_BE_SKIPPED_MASK | drawOp); 658 mWriter.writeInt(0xdeaddead); 659 mBufferSize = mWriter.size(); 660 return mWriter.peek32(mBufferSize - sizeof(int32_t)); 661 } 662 mWriter.writeInt(drawOp); 663 return NULL; 664 } 665 666 inline void addSkip(uint32_t* location) { 667 if (location) { 668 *location = (int32_t) (mWriter.size() - mBufferSize); 669 } 670 } 671 672 inline void addInt(int32_t value) { 673 mWriter.writeInt(value); 674 } 675 676 inline void addSize(uint32_t w, uint32_t h) { 677 mWriter.writeInt(w); 678 mWriter.writeInt(h); 679 } 680 681 void addInts(const int32_t* values, uint32_t count) { 682 mWriter.writeInt(count); 683 for (uint32_t i = 0; i < count; i++) { 684 mWriter.writeInt(values[i]); 685 } 686 } 687 688 void addUInts(const uint32_t* values, int8_t count) { 689 mWriter.writeInt(count); 690 for (int8_t i = 0; i < count; i++) { 691 mWriter.writeInt(values[i]); 692 } 693 } 694 695 inline void addFloat(float value) { 696 mWriter.writeScalar(value); 697 } 698 699 void addFloats(const float* values, int32_t count) { 700 mWriter.writeInt(count); 701 for (int32_t i = 0; i < count; i++) { 702 mWriter.writeScalar(values[i]); 703 } 704 } 705 706 inline void addPoint(float x, float y) { 707 mWriter.writeScalar(x); 708 mWriter.writeScalar(y); 709 } 710 711 inline void addBounds(float left, float top, float right, float bottom) { 712 mWriter.writeScalar(left); 713 mWriter.writeScalar(top); 714 mWriter.writeScalar(right); 715 mWriter.writeScalar(bottom); 716 } 717 718 inline void addText(const void* text, size_t byteLength) { 719 mWriter.writeInt(byteLength); 720 mWriter.writePad(text, byteLength); 721 } 722 723 inline void addPath(SkPath* path) { 724 if (!path) { 725 addInt((int) NULL); 726 return; 727 } 728 729 SkPath* pathCopy = mPathMap.valueFor(path); 730 if (pathCopy == NULL || pathCopy->getGenerationID() != path->getGenerationID()) { 731 pathCopy = new SkPath(*path); 732 pathCopy->setSourcePath(path); 733 // replaceValueFor() performs an add if the entry doesn't exist 734 mPathMap.replaceValueFor(path, pathCopy); 735 mPaths.add(pathCopy); 736 } 737 738 addInt((int) pathCopy); 739 } 740 741 inline void addPaint(SkPaint* paint) { 742 if (!paint) { 743 addInt((int) NULL); 744 return; 745 } 746 747 SkPaint* paintCopy = mPaintMap.valueFor(paint); 748 if (paintCopy == NULL || paintCopy->getGenerationID() != paint->getGenerationID()) { 749 paintCopy = new SkPaint(*paint); 750 // replaceValueFor() performs an add if the entry doesn't exist 751 mPaintMap.replaceValueFor(paint, paintCopy); 752 mPaints.add(paintCopy); 753 } 754 755 addInt((int) paintCopy); 756 } 757 758 inline void addDisplayList(DisplayList* displayList) { 759 // TODO: To be safe, the display list should be ref-counted in the 760 // resources cache, but we rely on the caller (UI toolkit) to 761 // do the right thing for now 762 addInt((int) displayList); 763 } 764 765 inline void addMatrix(SkMatrix* matrix) { 766 // Copying the matrix is cheap and prevents against the user changing the original 767 // matrix before the operation that uses it 768 SkMatrix* copy = new SkMatrix(*matrix); 769 addInt((int) copy); 770 mMatrices.add(copy); 771 } 772 773 inline void addBitmap(SkBitmap* bitmap) { 774 // Note that this assumes the bitmap is immutable. There are cases this won't handle 775 // correctly, such as creating the bitmap from scratch, drawing with it, changing its 776 // contents, and drawing again. The only fix would be to always copy it the first time, 777 // which doesn't seem worth the extra cycles for this unlikely case. 778 addInt((int) bitmap); 779 mBitmapResources.add(bitmap); 780 Caches::getInstance().resourceCache.incrementRefcount(bitmap); 781 } 782 783 inline void addShader(SkiaShader* shader) { 784 if (!shader) { 785 addInt((int) NULL); 786 return; 787 } 788 789 SkiaShader* shaderCopy = mShaderMap.valueFor(shader); 790 // TODO: We also need to handle generation ID changes in compose shaders 791 if (shaderCopy == NULL || shaderCopy->getGenerationId() != shader->getGenerationId()) { 792 shaderCopy = shader->copy(); 793 // replaceValueFor() performs an add if the entry doesn't exist 794 mShaderMap.replaceValueFor(shader, shaderCopy); 795 mShaders.add(shaderCopy); 796 Caches::getInstance().resourceCache.incrementRefcount(shaderCopy); 797 } 798 799 addInt((int) shaderCopy); 800 } 801 802 inline void addColorFilter(SkiaColorFilter* colorFilter) { 803 addInt((int) colorFilter); 804 mFilterResources.add(colorFilter); 805 Caches::getInstance().resourceCache.incrementRefcount(colorFilter); 806 } 807 808 Vector<SkBitmap*> mBitmapResources; 809 Vector<SkiaColorFilter*> mFilterResources; 810 811 Vector<SkPaint*> mPaints; 812 DefaultKeyedVector<SkPaint*, SkPaint*> mPaintMap; 813 814 Vector<SkPath*> mPaths; 815 DefaultKeyedVector<SkPath*, SkPath*> mPathMap; 816 817 Vector<SkiaShader*> mShaders; 818 DefaultKeyedVector<SkiaShader*, SkiaShader*> mShaderMap; 819 820 Vector<SkMatrix*> mMatrices; 821 822 SkWriter32 mWriter; 823 uint32_t mBufferSize; 824 825 int mRestoreSaveCount; 826 827 float mTranslateX; 828 float mTranslateY; 829 bool mHasTranslate; 830 831 bool mHasDrawOps; 832 833 friend class DisplayList; 834 835}; // class DisplayListRenderer 836 837}; // namespace uirenderer 838}; // namespace android 839 840#endif // ANDROID_HWUI_DISPLAY_LIST_RENDERER_H 841