Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 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 | |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 17 | #ifndef ANDROID_HWUI_DISPLAY_LIST_RENDERER_H |
| 18 | #define ANDROID_HWUI_DISPLAY_LIST_RENDERER_H |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 19 | |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 20 | #include <SkMatrix.h> |
| 21 | #include <SkPaint.h> |
| 22 | #include <SkPath.h> |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 23 | #include <cutils/compiler.h> |
| 24 | |
Chris Craik | 0776a60 | 2013-02-14 15:36:01 -0800 | [diff] [blame] | 25 | #include "DisplayList.h" |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 26 | #include "DisplayListLogBuffer.h" |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 27 | #include "OpenGLRenderer.h" |
| 28 | |
| 29 | namespace android { |
| 30 | namespace uirenderer { |
| 31 | |
| 32 | /////////////////////////////////////////////////////////////////////////////// |
| 33 | // Defines |
| 34 | /////////////////////////////////////////////////////////////////////////////// |
| 35 | |
Romain Guy | 6d7475d | 2011-07-27 16:28:21 -0700 | [diff] [blame] | 36 | #define MIN_WRITER_SIZE 4096 |
Romain Guy | 33f6beb | 2012-02-16 19:24:51 -0800 | [diff] [blame] | 37 | #define OP_MAY_BE_SKIPPED_MASK 0xff000000 |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 38 | |
Romain Guy | ffac7fc | 2011-01-13 17:21:49 -0800 | [diff] [blame] | 39 | // Debug |
| 40 | #if DEBUG_DISPLAY_LIST |
Steve Block | 5baa3a6 | 2011-12-20 16:23:08 +0000 | [diff] [blame] | 41 | #define DISPLAY_LIST_LOGD(...) ALOGD(__VA_ARGS__) |
Romain Guy | ffac7fc | 2011-01-13 17:21:49 -0800 | [diff] [blame] | 42 | #else |
| 43 | #define DISPLAY_LIST_LOGD(...) |
| 44 | #endif |
| 45 | |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 46 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | b051e89 | 2010-09-28 19:09:36 -0700 | [diff] [blame] | 47 | // Display list |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 48 | /////////////////////////////////////////////////////////////////////////////// |
| 49 | |
Chris Craik | c3566d0 | 2013-02-04 16:16:33 -0800 | [diff] [blame] | 50 | class DeferredDisplayList; |
Romain Guy | b051e89 | 2010-09-28 19:09:36 -0700 | [diff] [blame] | 51 | class DisplayListRenderer; |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 52 | class DisplayListOp; |
| 53 | class DrawOp; |
| 54 | class StateOp; |
| 55 | |
Romain Guy | b051e89 | 2010-09-28 19:09:36 -0700 | [diff] [blame] | 56 | /** |
| 57 | * Records drawing commands in a display list for latter playback. |
| 58 | */ |
| 59 | class DisplayListRenderer: public OpenGLRenderer { |
| 60 | public: |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 61 | ANDROID_API DisplayListRenderer(); |
| 62 | virtual ~DisplayListRenderer(); |
Romain Guy | b051e89 | 2010-09-28 19:09:36 -0700 | [diff] [blame] | 63 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 64 | ANDROID_API DisplayList* getDisplayList(DisplayList* displayList); |
Chet Haase | 5977baa | 2011-01-05 18:01:22 -0800 | [diff] [blame] | 65 | |
Romain Guy | 49c5fc0 | 2012-05-15 11:10:01 -0700 | [diff] [blame] | 66 | virtual bool isDeferred(); |
| 67 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 68 | virtual void setViewport(int width, int height); |
Romain Guy | 7c25aab | 2012-10-18 15:05:02 -0700 | [diff] [blame] | 69 | virtual status_t prepareDirty(float left, float top, float right, float bottom, bool opaque); |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 70 | virtual void finish(); |
Romain Guy | b051e89 | 2010-09-28 19:09:36 -0700 | [diff] [blame] | 71 | |
Romain Guy | 6554943 | 2012-03-26 16:45:05 -0700 | [diff] [blame] | 72 | virtual status_t callDrawGLFunction(Functor *functor, Rect& dirty); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 73 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 74 | virtual void interrupt(); |
| 75 | virtual void resume(); |
Chet Haase | daf98e9 | 2011-01-10 14:10:36 -0800 | [diff] [blame] | 76 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 77 | virtual int save(int flags); |
| 78 | virtual void restore(); |
| 79 | virtual void restoreToCount(int saveCount); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 80 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 81 | virtual int saveLayer(float left, float top, float right, float bottom, |
Chris Craik | ff78583 | 2013-03-08 13:12:16 -0800 | [diff] [blame] | 82 | int alpha, SkXfermode::Mode mode, int flags); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 83 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 84 | virtual void translate(float dx, float dy); |
| 85 | virtual void rotate(float degrees); |
| 86 | virtual void scale(float sx, float sy); |
| 87 | virtual void skew(float sx, float sy); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 88 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 89 | virtual void setMatrix(SkMatrix* matrix); |
| 90 | virtual void concatMatrix(SkMatrix* matrix); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 91 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 92 | virtual bool clipRect(float left, float top, float right, float bottom, SkRegion::Op op); |
Romain Guy | 735738c | 2012-12-03 12:34:51 -0800 | [diff] [blame] | 93 | virtual bool clipPath(SkPath* path, SkRegion::Op op); |
| 94 | virtual bool clipRegion(SkRegion* region, SkRegion::Op op); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 95 | |
Chris Craik | c3566d0 | 2013-02-04 16:16:33 -0800 | [diff] [blame] | 96 | virtual status_t drawDisplayList(DisplayList* displayList, Rect& dirty, int32_t flags); |
Chris Craik | a08f95c | 2013-03-15 17:24:33 -0700 | [diff] [blame] | 97 | virtual status_t drawLayer(Layer* layer, float x, float y); |
Chet Haase | 4865909 | 2012-05-31 15:21:51 -0700 | [diff] [blame] | 98 | virtual status_t drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint); |
| 99 | virtual status_t drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint); |
| 100 | virtual status_t drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop, |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 101 | float srcRight, float srcBottom, float dstLeft, float dstTop, |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 102 | float dstRight, float dstBottom, SkPaint* paint); |
Chet Haase | 4865909 | 2012-05-31 15:21:51 -0700 | [diff] [blame] | 103 | virtual status_t drawBitmapData(SkBitmap* bitmap, float left, float top, SkPaint* paint); |
| 104 | virtual status_t drawBitmapMesh(SkBitmap* bitmap, int meshWidth, int meshHeight, |
Romain Guy | 5a7b466 | 2011-01-20 19:09:30 -0800 | [diff] [blame] | 105 | float* vertices, int* colors, SkPaint* paint); |
Romain Guy | 3b748a4 | 2013-04-17 18:54:38 -0700 | [diff] [blame] | 106 | virtual status_t drawPatch(SkBitmap* bitmap, Res_png_9patch* patch, |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 107 | float left, float top, float right, float bottom, SkPaint* paint); |
Chet Haase | 4865909 | 2012-05-31 15:21:51 -0700 | [diff] [blame] | 108 | virtual status_t drawColor(int color, SkXfermode::Mode mode); |
| 109 | virtual status_t drawRect(float left, float top, float right, float bottom, SkPaint* paint); |
| 110 | virtual status_t drawRoundRect(float left, float top, float right, float bottom, |
Romain Guy | 01d58e4 | 2011-01-19 21:54:02 -0800 | [diff] [blame] | 111 | float rx, float ry, SkPaint* paint); |
Chet Haase | 4865909 | 2012-05-31 15:21:51 -0700 | [diff] [blame] | 112 | virtual status_t drawCircle(float x, float y, float radius, SkPaint* paint); |
| 113 | virtual status_t drawOval(float left, float top, float right, float bottom, SkPaint* paint); |
| 114 | virtual status_t drawArc(float left, float top, float right, float bottom, |
Romain Guy | 8b2f526 | 2011-01-23 16:15:02 -0800 | [diff] [blame] | 115 | float startAngle, float sweepAngle, bool useCenter, SkPaint* paint); |
Chet Haase | 4865909 | 2012-05-31 15:21:51 -0700 | [diff] [blame] | 116 | virtual status_t drawPath(SkPath* path, SkPaint* paint); |
| 117 | virtual status_t drawLines(float* points, int count, SkPaint* paint); |
| 118 | virtual status_t drawPoints(float* points, int count, SkPaint* paint); |
Chet Haase | 4865909 | 2012-05-31 15:21:51 -0700 | [diff] [blame] | 119 | virtual status_t drawTextOnPath(const char* text, int bytesCount, int count, SkPath* path, |
Romain Guy | 325740f | 2012-02-24 16:48:34 -0800 | [diff] [blame] | 120 | float hOffset, float vOffset, SkPaint* paint); |
Chet Haase | 4865909 | 2012-05-31 15:21:51 -0700 | [diff] [blame] | 121 | virtual status_t drawPosText(const char* text, int bytesCount, int count, |
| 122 | const float* positions, SkPaint* paint); |
Chris Craik | 527a3aa | 2013-03-04 10:19:31 -0800 | [diff] [blame] | 123 | virtual status_t drawText(const char* text, int bytesCount, int count, float x, float y, |
Chris Craik | 4154182 | 2013-05-03 16:35:54 -0700 | [diff] [blame] | 124 | const float* positions, SkPaint* paint, float totalAdvance, const Rect& bounds, |
| 125 | DrawOpMode drawOpMode); |
Chris Craik | 527a3aa | 2013-03-04 10:19:31 -0800 | [diff] [blame] | 126 | |
Romain Guy | 672433d | 2013-01-04 19:05:13 -0800 | [diff] [blame] | 127 | virtual status_t drawRects(const float* rects, int count, SkPaint* paint); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 128 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 129 | virtual void resetShader(); |
| 130 | virtual void setupShader(SkiaShader* shader); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 131 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 132 | virtual void resetColorFilter(); |
| 133 | virtual void setupColorFilter(SkiaColorFilter* filter); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 134 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 135 | virtual void resetShadow(); |
| 136 | virtual void setupShadow(float radius, float dx, float dy, int color); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 137 | |
Romain Guy | 5ff9df6 | 2012-01-23 17:09:05 -0800 | [diff] [blame] | 138 | virtual void resetPaintFilter(); |
| 139 | virtual void setupPaintFilter(int clearBits, int setBits); |
| 140 | |
Romain Guy | 7953745 | 2011-10-12 13:48:51 -0700 | [diff] [blame] | 141 | ANDROID_API void reset(); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 142 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 143 | sp<DisplayListData> getDisplayListData() const { |
| 144 | return mDisplayListData; |
Romain Guy | b051e89 | 2010-09-28 19:09:36 -0700 | [diff] [blame] | 145 | } |
| 146 | |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 147 | const Vector<SkBitmap*>& getBitmapResources() const { |
| 148 | return mBitmapResources; |
Romain Guy | b051e89 | 2010-09-28 19:09:36 -0700 | [diff] [blame] | 149 | } |
| 150 | |
Romain Guy | 49c5fc0 | 2012-05-15 11:10:01 -0700 | [diff] [blame] | 151 | const Vector<SkBitmap*>& getOwnedBitmapResources() const { |
| 152 | return mOwnedBitmapResources; |
| 153 | } |
| 154 | |
Romain Guy | d586ad9 | 2011-06-22 16:14:36 -0700 | [diff] [blame] | 155 | const Vector<SkiaColorFilter*>& getFilterResources() const { |
| 156 | return mFilterResources; |
| 157 | } |
| 158 | |
Romain Guy | e3b0a01 | 2013-06-26 15:45:41 -0700 | [diff] [blame] | 159 | const Vector<Res_png_9patch*>& getPatchResources() const { |
| 160 | return mPatchResources; |
| 161 | } |
| 162 | |
Romain Guy | 24c0021 | 2011-01-14 15:31:00 -0800 | [diff] [blame] | 163 | const Vector<SkiaShader*>& getShaders() const { |
| 164 | return mShaders; |
Romain Guy | b051e89 | 2010-09-28 19:09:36 -0700 | [diff] [blame] | 165 | } |
| 166 | |
Chet Haase | d98aa2d | 2010-10-25 15:47:32 -0700 | [diff] [blame] | 167 | const Vector<SkPaint*>& getPaints() const { |
| 168 | return mPaints; |
| 169 | } |
| 170 | |
Romain Guy | 2fc941e | 2011-02-03 15:06:05 -0800 | [diff] [blame] | 171 | const Vector<SkPath*>& getPaths() const { |
| 172 | return mPaths; |
| 173 | } |
| 174 | |
Chet Haase | d34dd71 | 2012-05-02 18:50:34 -0700 | [diff] [blame] | 175 | const SortedVector<SkPath*>& getSourcePaths() const { |
| 176 | return mSourcePaths; |
| 177 | } |
| 178 | |
Romain Guy | 735738c | 2012-12-03 12:34:51 -0800 | [diff] [blame] | 179 | const Vector<SkRegion*>& getRegions() const { |
| 180 | return mRegions; |
| 181 | } |
| 182 | |
Chet Haase | 603f6de | 2012-09-14 15:31:25 -0700 | [diff] [blame] | 183 | const Vector<Layer*>& getLayers() const { |
| 184 | return mLayers; |
| 185 | } |
| 186 | |
Chet Haase | d98aa2d | 2010-10-25 15:47:32 -0700 | [diff] [blame] | 187 | const Vector<SkMatrix*>& getMatrices() const { |
| 188 | return mMatrices; |
| 189 | } |
| 190 | |
Romain Guy | 54c1a64 | 2012-09-27 17:55:46 -0700 | [diff] [blame] | 191 | uint32_t getFunctorCount() const { |
| 192 | return mFunctorCount; |
| 193 | } |
| 194 | |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 195 | private: |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 196 | void insertRestoreToCount(); |
| 197 | void insertTranslate(); |
Romain Guy | 27454a4 | 2011-01-23 12:01:41 -0800 | [diff] [blame] | 198 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 199 | LinearAllocator& alloc() { return mDisplayListData->allocator; } |
| 200 | void addStateOp(StateOp* op); |
Romain Guy | 0f66753 | 2013-03-01 14:31:04 -0800 | [diff] [blame] | 201 | void addDrawOp(DrawOp* op); |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 202 | void addOpInternal(DisplayListOp* op) { |
Romain Guy | 27454a4 | 2011-01-23 12:01:41 -0800 | [diff] [blame] | 203 | insertRestoreToCount(); |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 204 | insertTranslate(); |
| 205 | mDisplayListData->displayListOps.add(op); |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 206 | } |
| 207 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 208 | template<class T> |
| 209 | inline T* refBuffer(const T* srcBuffer, int32_t count) { |
| 210 | if (srcBuffer == NULL) return NULL; |
| 211 | T* dstBuffer = (T*) mDisplayListData->allocator.alloc(count * sizeof(T)); |
| 212 | memcpy(dstBuffer, srcBuffer, count * sizeof(T)); |
| 213 | return dstBuffer; |
Romain Guy | 33f6beb | 2012-02-16 19:24:51 -0800 | [diff] [blame] | 214 | } |
| 215 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 216 | inline char* refText(const char* text, size_t byteLength) { |
| 217 | return (char*) refBuffer<uint8_t>((uint8_t*)text, byteLength); |
Romain Guy | 33f6beb | 2012-02-16 19:24:51 -0800 | [diff] [blame] | 218 | } |
| 219 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 220 | inline SkPath* refPath(SkPath* path) { |
| 221 | if (!path) return NULL; |
Romain Guy | 2fc941e | 2011-02-03 15:06:05 -0800 | [diff] [blame] | 222 | |
| 223 | SkPath* pathCopy = mPathMap.valueFor(path); |
| 224 | if (pathCopy == NULL || pathCopy->getGenerationID() != path->getGenerationID()) { |
Romain Guy | b29cfbf | 2011-03-18 16:24:19 -0700 | [diff] [blame] | 225 | pathCopy = new SkPath(*path); |
Romain Guy | 4bcb746 | 2012-02-23 17:08:38 -0800 | [diff] [blame] | 226 | pathCopy->setSourcePath(path); |
Romain Guy | 96ebc6b | 2012-02-21 18:32:32 -0800 | [diff] [blame] | 227 | // replaceValueFor() performs an add if the entry doesn't exist |
| 228 | mPathMap.replaceValueFor(path, pathCopy); |
Romain Guy | b29cfbf | 2011-03-18 16:24:19 -0700 | [diff] [blame] | 229 | mPaths.add(pathCopy); |
Romain Guy | 2fc941e | 2011-02-03 15:06:05 -0800 | [diff] [blame] | 230 | } |
Chet Haase | d34dd71 | 2012-05-02 18:50:34 -0700 | [diff] [blame] | 231 | if (mSourcePaths.indexOf(path) < 0) { |
Romain Guy | 58ecc20 | 2012-09-07 11:58:36 -0700 | [diff] [blame] | 232 | mCaches.resourceCache.incrementRefcount(path); |
Chet Haase | d34dd71 | 2012-05-02 18:50:34 -0700 | [diff] [blame] | 233 | mSourcePaths.add(path); |
| 234 | } |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 235 | return pathCopy; |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 236 | } |
| 237 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 238 | inline SkPaint* refPaint(SkPaint* paint) { |
Romain Guy | 24c0021 | 2011-01-14 15:31:00 -0800 | [diff] [blame] | 239 | if (!paint) { |
Chet Haase | e816bae | 2012-08-09 13:39:02 -0700 | [diff] [blame] | 240 | return paint; |
Chet Haase | d98aa2d | 2010-10-25 15:47:32 -0700 | [diff] [blame] | 241 | } |
Romain Guy | 0fe478e | 2010-11-08 12:08:41 -0800 | [diff] [blame] | 242 | |
Romain Guy | 22d4184 | 2012-01-19 18:33:25 -0800 | [diff] [blame] | 243 | SkPaint* paintCopy = mPaintMap.valueFor(paint); |
Chet Haase | d98aa2d | 2010-10-25 15:47:32 -0700 | [diff] [blame] | 244 | if (paintCopy == NULL || paintCopy->getGenerationID() != paint->getGenerationID()) { |
| 245 | paintCopy = new SkPaint(*paint); |
Romain Guy | 96ebc6b | 2012-02-21 18:32:32 -0800 | [diff] [blame] | 246 | // replaceValueFor() performs an add if the entry doesn't exist |
| 247 | mPaintMap.replaceValueFor(paint, paintCopy); |
Chet Haase | d98aa2d | 2010-10-25 15:47:32 -0700 | [diff] [blame] | 248 | mPaints.add(paintCopy); |
| 249 | } |
Romain Guy | 0fe478e | 2010-11-08 12:08:41 -0800 | [diff] [blame] | 250 | |
Chet Haase | e816bae | 2012-08-09 13:39:02 -0700 | [diff] [blame] | 251 | return paintCopy; |
Romain Guy | 0fe478e | 2010-11-08 12:08:41 -0800 | [diff] [blame] | 252 | } |
| 253 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 254 | inline SkRegion* refRegion(SkRegion* region) { |
Romain Guy | 735738c | 2012-12-03 12:34:51 -0800 | [diff] [blame] | 255 | if (!region) { |
Romain Guy | 735738c | 2012-12-03 12:34:51 -0800 | [diff] [blame] | 256 | return region; |
| 257 | } |
| 258 | |
| 259 | SkRegion* regionCopy = mRegionMap.valueFor(region); |
| 260 | // TODO: Add generation ID to SkRegion |
| 261 | if (regionCopy == NULL) { |
| 262 | regionCopy = new SkRegion(*region); |
| 263 | // replaceValueFor() performs an add if the entry doesn't exist |
| 264 | mRegionMap.replaceValueFor(region, regionCopy); |
| 265 | mRegions.add(regionCopy); |
| 266 | } |
| 267 | |
Romain Guy | 735738c | 2012-12-03 12:34:51 -0800 | [diff] [blame] | 268 | return regionCopy; |
| 269 | } |
| 270 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 271 | inline SkMatrix* refMatrix(SkMatrix* matrix) { |
Romain Guy | 4e7b772 | 2013-07-16 13:47:01 -0700 | [diff] [blame] | 272 | if (matrix) { |
| 273 | // Copying the matrix is cheap and prevents against the user changing |
| 274 | // the original matrix before the operation that uses it |
| 275 | SkMatrix* copy = new SkMatrix(*matrix); |
| 276 | mMatrices.add(copy); |
| 277 | return copy; |
| 278 | } |
| 279 | return matrix; |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 280 | } |
| 281 | |
Romain Guy | ce4a7df | 2013-03-28 11:32:33 -0700 | [diff] [blame] | 282 | inline Layer* refLayer(Layer* layer) { |
| 283 | mLayers.add(layer); |
| 284 | mCaches.resourceCache.incrementRefcount(layer); |
| 285 | return layer; |
| 286 | } |
| 287 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 288 | inline SkBitmap* refBitmap(SkBitmap* bitmap) { |
Chet Haase | d98aa2d | 2010-10-25 15:47:32 -0700 | [diff] [blame] | 289 | // Note that this assumes the bitmap is immutable. There are cases this won't handle |
| 290 | // correctly, such as creating the bitmap from scratch, drawing with it, changing its |
| 291 | // contents, and drawing again. The only fix would be to always copy it the first time, |
| 292 | // which doesn't seem worth the extra cycles for this unlikely case. |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 293 | mBitmapResources.add(bitmap); |
Romain Guy | 58ecc20 | 2012-09-07 11:58:36 -0700 | [diff] [blame] | 294 | mCaches.resourceCache.incrementRefcount(bitmap); |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 295 | return bitmap; |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 296 | } |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 297 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 298 | inline SkBitmap* refBitmapData(SkBitmap* bitmap) { |
Romain Guy | 49c5fc0 | 2012-05-15 11:10:01 -0700 | [diff] [blame] | 299 | mOwnedBitmapResources.add(bitmap); |
Romain Guy | 58ecc20 | 2012-09-07 11:58:36 -0700 | [diff] [blame] | 300 | mCaches.resourceCache.incrementRefcount(bitmap); |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 301 | return bitmap; |
Romain Guy | 49c5fc0 | 2012-05-15 11:10:01 -0700 | [diff] [blame] | 302 | } |
| 303 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 304 | inline SkiaShader* refShader(SkiaShader* shader) { |
| 305 | if (!shader) return NULL; |
Romain Guy | 24c0021 | 2011-01-14 15:31:00 -0800 | [diff] [blame] | 306 | |
| 307 | SkiaShader* shaderCopy = mShaderMap.valueFor(shader); |
| 308 | // TODO: We also need to handle generation ID changes in compose shaders |
Romain Guy | 1f1fcb7 | 2011-01-14 15:37:54 -0800 | [diff] [blame] | 309 | if (shaderCopy == NULL || shaderCopy->getGenerationId() != shader->getGenerationId()) { |
Romain Guy | 24c0021 | 2011-01-14 15:31:00 -0800 | [diff] [blame] | 310 | shaderCopy = shader->copy(); |
Romain Guy | 96ebc6b | 2012-02-21 18:32:32 -0800 | [diff] [blame] | 311 | // replaceValueFor() performs an add if the entry doesn't exist |
| 312 | mShaderMap.replaceValueFor(shader, shaderCopy); |
Romain Guy | 1f1fcb7 | 2011-01-14 15:37:54 -0800 | [diff] [blame] | 313 | mShaders.add(shaderCopy); |
Romain Guy | 58ecc20 | 2012-09-07 11:58:36 -0700 | [diff] [blame] | 314 | mCaches.resourceCache.incrementRefcount(shaderCopy); |
Romain Guy | 24c0021 | 2011-01-14 15:31:00 -0800 | [diff] [blame] | 315 | } |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 316 | return shaderCopy; |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 317 | } |
| 318 | |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 319 | inline SkiaColorFilter* refColorFilter(SkiaColorFilter* colorFilter) { |
Chet Haase | ad93c2b | 2010-10-22 16:17:12 -0700 | [diff] [blame] | 320 | mFilterResources.add(colorFilter); |
Romain Guy | 58ecc20 | 2012-09-07 11:58:36 -0700 | [diff] [blame] | 321 | mCaches.resourceCache.incrementRefcount(colorFilter); |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 322 | return colorFilter; |
Chet Haase | ad93c2b | 2010-10-22 16:17:12 -0700 | [diff] [blame] | 323 | } |
| 324 | |
Romain Guy | e3b0a01 | 2013-06-26 15:45:41 -0700 | [diff] [blame] | 325 | inline Res_png_9patch* refPatch(Res_png_9patch* patch) { |
| 326 | mPatchResources.add(patch); |
| 327 | mCaches.resourceCache.incrementRefcount(patch); |
| 328 | return patch; |
| 329 | } |
| 330 | |
Chet Haase | 5c13d89 | 2010-10-08 08:37:55 -0700 | [diff] [blame] | 331 | Vector<SkBitmap*> mBitmapResources; |
Romain Guy | 49c5fc0 | 2012-05-15 11:10:01 -0700 | [diff] [blame] | 332 | Vector<SkBitmap*> mOwnedBitmapResources; |
Chet Haase | ad93c2b | 2010-10-22 16:17:12 -0700 | [diff] [blame] | 333 | Vector<SkiaColorFilter*> mFilterResources; |
Romain Guy | e3b0a01 | 2013-06-26 15:45:41 -0700 | [diff] [blame] | 334 | Vector<Res_png_9patch*> mPatchResources; |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 335 | |
Chet Haase | d98aa2d | 2010-10-25 15:47:32 -0700 | [diff] [blame] | 336 | Vector<SkPaint*> mPaints; |
Romain Guy | 0fe478e | 2010-11-08 12:08:41 -0800 | [diff] [blame] | 337 | DefaultKeyedVector<SkPaint*, SkPaint*> mPaintMap; |
Romain Guy | 24c0021 | 2011-01-14 15:31:00 -0800 | [diff] [blame] | 338 | |
Romain Guy | 2fc941e | 2011-02-03 15:06:05 -0800 | [diff] [blame] | 339 | Vector<SkPath*> mPaths; |
| 340 | DefaultKeyedVector<SkPath*, SkPath*> mPathMap; |
| 341 | |
Chet Haase | d34dd71 | 2012-05-02 18:50:34 -0700 | [diff] [blame] | 342 | SortedVector<SkPath*> mSourcePaths; |
| 343 | |
Romain Guy | 735738c | 2012-12-03 12:34:51 -0800 | [diff] [blame] | 344 | Vector<SkRegion*> mRegions; |
| 345 | DefaultKeyedVector<SkRegion*, SkRegion*> mRegionMap; |
| 346 | |
Romain Guy | 24c0021 | 2011-01-14 15:31:00 -0800 | [diff] [blame] | 347 | Vector<SkiaShader*> mShaders; |
| 348 | DefaultKeyedVector<SkiaShader*, SkiaShader*> mShaderMap; |
| 349 | |
Chet Haase | d98aa2d | 2010-10-25 15:47:32 -0700 | [diff] [blame] | 350 | Vector<SkMatrix*> mMatrices; |
| 351 | |
Chet Haase | 603f6de | 2012-09-14 15:31:25 -0700 | [diff] [blame] | 352 | Vector<Layer*> mLayers; |
| 353 | |
Romain Guy | 27454a4 | 2011-01-23 12:01:41 -0800 | [diff] [blame] | 354 | int mRestoreSaveCount; |
Romain Guy | 33f6beb | 2012-02-16 19:24:51 -0800 | [diff] [blame] | 355 | |
Romain Guy | 58ecc20 | 2012-09-07 11:58:36 -0700 | [diff] [blame] | 356 | Caches& mCaches; |
Chris Craik | 2af4635 | 2012-11-26 18:30:17 -0800 | [diff] [blame] | 357 | sp<DisplayListData> mDisplayListData; |
Romain Guy | 58ecc20 | 2012-09-07 11:58:36 -0700 | [diff] [blame] | 358 | |
Romain Guy | 33f6beb | 2012-02-16 19:24:51 -0800 | [diff] [blame] | 359 | float mTranslateX; |
| 360 | float mTranslateY; |
| 361 | bool mHasTranslate; |
Romain Guy | 04c9d8c | 2011-08-25 14:01:48 -0700 | [diff] [blame] | 362 | bool mHasDrawOps; |
Romain Guy | 27454a4 | 2011-01-23 12:01:41 -0800 | [diff] [blame] | 363 | |
Romain Guy | 54c1a64 | 2012-09-27 17:55:46 -0700 | [diff] [blame] | 364 | uint32_t mFunctorCount; |
| 365 | |
Romain Guy | b051e89 | 2010-09-28 19:09:36 -0700 | [diff] [blame] | 366 | friend class DisplayList; |
| 367 | |
Romain Guy | 4aa9057 | 2010-09-26 18:40:37 -0700 | [diff] [blame] | 368 | }; // class DisplayListRenderer |
| 369 | |
| 370 | }; // namespace uirenderer |
| 371 | }; // namespace android |
| 372 | |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 373 | #endif // ANDROID_HWUI_DISPLAY_LIST_RENDERER_H |