commit-bot@chromium.org | c4b21e6 | 2014-04-11 18:33:31 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2014 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 8 | #include "SkBigPicture.h" |
mtklein | d711d11 | 2015-07-01 07:04:37 -0700 | [diff] [blame] | 9 | #include "SkCanvasPriv.h" |
dandov | b3c9d1c | 2014-08-12 08:34:29 -0700 | [diff] [blame] | 10 | #include "SkPatchUtils.h" |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 11 | #include "SkPicture.h" |
mtklein | 98b8485 | 2015-04-21 15:23:59 -0700 | [diff] [blame] | 12 | #include "SkPictureUtils.h" |
| 13 | #include "SkRecorder.h" |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 14 | |
reed | 5617900 | 2015-07-07 06:11:19 -0700 | [diff] [blame] | 15 | //#define WRAP_BITMAP_AS_IMAGE |
| 16 | |
reed | 3cb3840 | 2015-02-06 08:36:15 -0800 | [diff] [blame] | 17 | SkDrawableList::~SkDrawableList() { |
reed | 1bdfd3f | 2014-11-24 14:41:51 -0800 | [diff] [blame] | 18 | fArray.unrefAll(); |
| 19 | } |
| 20 | |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 21 | SkBigPicture::SnapshotArray* SkDrawableList::newDrawableSnapshot() { |
reed | 1bdfd3f | 2014-11-24 14:41:51 -0800 | [diff] [blame] | 22 | const int count = fArray.count(); |
| 23 | if (0 == count) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 24 | return nullptr; |
reed | 1bdfd3f | 2014-11-24 14:41:51 -0800 | [diff] [blame] | 25 | } |
| 26 | SkAutoTMalloc<const SkPicture*> pics(count); |
| 27 | for (int i = 0; i < count; ++i) { |
| 28 | pics[i] = fArray[i]->newPictureSnapshot(); |
| 29 | } |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 30 | return new SkBigPicture::SnapshotArray(pics.detach(), count); |
reed | 1bdfd3f | 2014-11-24 14:41:51 -0800 | [diff] [blame] | 31 | } |
| 32 | |
reed | 3cb3840 | 2015-02-06 08:36:15 -0800 | [diff] [blame] | 33 | void SkDrawableList::append(SkDrawable* drawable) { |
reed | 1bdfd3f | 2014-11-24 14:41:51 -0800 | [diff] [blame] | 34 | *fArray.append() = SkRef(drawable); |
| 35 | } |
| 36 | |
| 37 | /////////////////////////////////////////////////////////////////////////////////////////////// |
| 38 | |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 39 | SkRecorder::SkRecorder(SkRecord* record, int width, int height, SkMiniRecorder* mr) |
reed | 78e2768 | 2014-11-19 08:04:34 -0800 | [diff] [blame] | 40 | : SkCanvas(SkIRect::MakeWH(width, height), SkCanvas::kConservativeRasterClip_InitFlag) |
mtklein | d711d11 | 2015-07-01 07:04:37 -0700 | [diff] [blame] | 41 | , fDrawPictureMode(Record_DrawPictureMode) |
mtklein | 98b8485 | 2015-04-21 15:23:59 -0700 | [diff] [blame] | 42 | , fApproxBytesUsedBySubPictures(0) |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 43 | , fRecord(record) |
| 44 | , fMiniRecorder(mr) {} |
reed | 78e2768 | 2014-11-19 08:04:34 -0800 | [diff] [blame] | 45 | |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 46 | SkRecorder::SkRecorder(SkRecord* record, const SkRect& bounds, SkMiniRecorder* mr) |
reed | 78e2768 | 2014-11-19 08:04:34 -0800 | [diff] [blame] | 47 | : SkCanvas(bounds.roundOut(), SkCanvas::kConservativeRasterClip_InitFlag) |
mtklein | d711d11 | 2015-07-01 07:04:37 -0700 | [diff] [blame] | 48 | , fDrawPictureMode(Record_DrawPictureMode) |
mtklein | 98b8485 | 2015-04-21 15:23:59 -0700 | [diff] [blame] | 49 | , fApproxBytesUsedBySubPictures(0) |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 50 | , fRecord(record) |
| 51 | , fMiniRecorder(mr) {} |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 52 | |
mtklein | d711d11 | 2015-07-01 07:04:37 -0700 | [diff] [blame] | 53 | void SkRecorder::reset(SkRecord* record, const SkRect& bounds, |
| 54 | DrawPictureMode dpm, SkMiniRecorder* mr) { |
mtklein | feaadee | 2015-04-08 11:25:48 -0700 | [diff] [blame] | 55 | this->forgetRecord(); |
mtklein | d711d11 | 2015-07-01 07:04:37 -0700 | [diff] [blame] | 56 | fDrawPictureMode = dpm; |
mtklein | feaadee | 2015-04-08 11:25:48 -0700 | [diff] [blame] | 57 | fRecord = record; |
| 58 | this->resetForNextPicture(bounds.roundOut()); |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 59 | fMiniRecorder = mr; |
mtklein | feaadee | 2015-04-08 11:25:48 -0700 | [diff] [blame] | 60 | } |
| 61 | |
commit-bot@chromium.org | 732bd66 | 2014-04-24 15:22:55 +0000 | [diff] [blame] | 62 | void SkRecorder::forgetRecord() { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 63 | fDrawableList.reset(nullptr); |
mtklein | 98b8485 | 2015-04-21 15:23:59 -0700 | [diff] [blame] | 64 | fApproxBytesUsedBySubPictures = 0; |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 65 | fRecord = nullptr; |
commit-bot@chromium.org | 732bd66 | 2014-04-24 15:22:55 +0000 | [diff] [blame] | 66 | } |
| 67 | |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 68 | // To make appending to fRecord a little less verbose. |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 69 | #define APPEND(T, ...) \ |
| 70 | if (fMiniRecorder) { \ |
| 71 | this->flushMiniRecorder(); \ |
| 72 | } \ |
mtklein | 449d9b7 | 2015-09-28 10:33:02 -0700 | [diff] [blame] | 73 | new (fRecord->append<SkRecords::T>()) SkRecords::T{__VA_ARGS__} |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 74 | |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 75 | #define TRY_MINIRECORDER(method, ...) \ |
| 76 | if (fMiniRecorder && fMiniRecorder->method(__VA_ARGS__)) { return; } |
| 77 | |
commit-bot@chromium.org | a095041 | 2014-05-29 16:52:40 +0000 | [diff] [blame] | 78 | // For methods which must call back into SkCanvas. |
| 79 | #define INHERITED(method, ...) this->SkCanvas::method(__VA_ARGS__) |
commit-bot@chromium.org | d9ce2be | 2014-04-09 23:30:28 +0000 | [diff] [blame] | 80 | |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 81 | // Use copy() only for optional arguments, to be copied if present or skipped if not. |
| 82 | // (For most types we just pass by value and let copy constructors do their thing.) |
| 83 | template <typename T> |
| 84 | T* SkRecorder::copy(const T* src) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 85 | if (nullptr == src) { |
| 86 | return nullptr; |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 87 | } |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 88 | return new (fRecord->alloc<T>()) T(*src); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 89 | } |
| 90 | |
| 91 | // This copy() is for arrays. |
| 92 | // It will work with POD or non-POD, though currently we only use it for POD. |
| 93 | template <typename T> |
reed | 2347b62 | 2014-08-07 12:19:50 -0700 | [diff] [blame] | 94 | T* SkRecorder::copy(const T src[], size_t count) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 95 | if (nullptr == src) { |
| 96 | return nullptr; |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 97 | } |
| 98 | T* dst = fRecord->alloc<T>(count); |
reed | 2347b62 | 2014-08-07 12:19:50 -0700 | [diff] [blame] | 99 | for (size_t i = 0; i < count; i++) { |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 100 | new (dst + i) T(src[i]); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 101 | } |
| 102 | return dst; |
| 103 | } |
| 104 | |
| 105 | // Specialization for copying strings, using memcpy. |
| 106 | // This measured around 2x faster for copying code points, |
| 107 | // but I found no corresponding speedup for other arrays. |
| 108 | template <> |
reed | 2347b62 | 2014-08-07 12:19:50 -0700 | [diff] [blame] | 109 | char* SkRecorder::copy(const char src[], size_t count) { |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 110 | if (nullptr == src) { |
| 111 | return nullptr; |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 112 | } |
| 113 | char* dst = fRecord->alloc<char>(count); |
| 114 | memcpy(dst, src, count); |
| 115 | return dst; |
| 116 | } |
| 117 | |
mtklein | 5f0e822 | 2014-08-22 11:44:26 -0700 | [diff] [blame] | 118 | // As above, assuming and copying a terminating \0. |
| 119 | template <> |
| 120 | char* SkRecorder::copy(const char* src) { |
| 121 | return this->copy(src, strlen(src)+1); |
| 122 | } |
| 123 | |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 124 | void SkRecorder::flushMiniRecorder() { |
| 125 | if (fMiniRecorder) { |
| 126 | SkMiniRecorder* mr = fMiniRecorder; |
mtklein | d41ea1d | 2015-05-20 10:16:49 -0700 | [diff] [blame] | 127 | fMiniRecorder = nullptr; // Needs to happen before flushAndReset() or we recurse forever. |
| 128 | mr->flushAndReset(this); |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 129 | } |
| 130 | } |
mtklein | 5f0e822 | 2014-08-22 11:44:26 -0700 | [diff] [blame] | 131 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 132 | void SkRecorder::onDrawPaint(const SkPaint& paint) { |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 133 | APPEND(DrawPaint, paint); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 134 | } |
| 135 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 136 | void SkRecorder::onDrawPoints(PointMode mode, |
| 137 | size_t count, |
| 138 | const SkPoint pts[], |
| 139 | const SkPaint& paint) { |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 140 | APPEND(DrawPoints, paint, mode, SkToUInt(count), this->copy(pts, count)); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 141 | } |
| 142 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 143 | void SkRecorder::onDrawRect(const SkRect& rect, const SkPaint& paint) { |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 144 | TRY_MINIRECORDER(drawRect, rect, paint); |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 145 | APPEND(DrawRect, paint, rect); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 146 | } |
| 147 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 148 | void SkRecorder::onDrawOval(const SkRect& oval, const SkPaint& paint) { |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 149 | APPEND(DrawOval, paint, oval); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 150 | } |
| 151 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 152 | void SkRecorder::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) { |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 153 | APPEND(DrawRRect, paint, rrect); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 154 | } |
| 155 | |
commit-bot@chromium.org | d9ce2be | 2014-04-09 23:30:28 +0000 | [diff] [blame] | 156 | void SkRecorder::onDrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) { |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 157 | APPEND(DrawDRRect, paint, outer, inner); |
commit-bot@chromium.org | d9ce2be | 2014-04-09 23:30:28 +0000 | [diff] [blame] | 158 | } |
| 159 | |
reed | a8db728 | 2015-07-07 10:22:31 -0700 | [diff] [blame] | 160 | void SkRecorder::onDrawDrawable(SkDrawable* drawable, const SkMatrix* matrix) { |
djsollen | aa6f739 | 2015-11-17 06:18:31 -0800 | [diff] [blame] | 161 | if (fDrawPictureMode == Record_DrawPictureMode) { |
| 162 | if (!fDrawableList) { |
| 163 | fDrawableList.reset(new SkDrawableList); |
| 164 | } |
| 165 | fDrawableList->append(drawable); |
| 166 | APPEND(DrawDrawable, this->copy(matrix), drawable->getBounds(), fDrawableList->count() - 1); |
| 167 | } else { |
| 168 | SkASSERT(fDrawPictureMode == Playback_DrawPictureMode); |
| 169 | drawable->draw(this, matrix); |
reed | 1bdfd3f | 2014-11-24 14:41:51 -0800 | [diff] [blame] | 170 | } |
reed | 6be2aa9 | 2014-11-18 11:08:05 -0800 | [diff] [blame] | 171 | } |
| 172 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 173 | void SkRecorder::onDrawPath(const SkPath& path, const SkPaint& paint) { |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 174 | TRY_MINIRECORDER(drawPath, path, paint); |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 175 | APPEND(DrawPath, paint, path); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 176 | } |
| 177 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 178 | void SkRecorder::onDrawBitmap(const SkBitmap& bitmap, |
| 179 | SkScalar left, |
| 180 | SkScalar top, |
| 181 | const SkPaint* paint) { |
reed | 5617900 | 2015-07-07 06:11:19 -0700 | [diff] [blame] | 182 | #ifdef WRAP_BITMAP_AS_IMAGE |
| 183 | SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bitmap)); |
| 184 | if (image) { |
| 185 | this->onDrawImage(image, left, top, paint); |
| 186 | } |
| 187 | #else |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 188 | APPEND(DrawBitmap, this->copy(paint), bitmap, left, top); |
reed | 5617900 | 2015-07-07 06:11:19 -0700 | [diff] [blame] | 189 | #endif |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 190 | } |
| 191 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 192 | void SkRecorder::onDrawBitmapRect(const SkBitmap& bitmap, |
| 193 | const SkRect* src, |
| 194 | const SkRect& dst, |
| 195 | const SkPaint* paint, |
reed | 562fe47 | 2015-07-28 07:35:14 -0700 | [diff] [blame] | 196 | SrcRectConstraint constraint) { |
reed | 5617900 | 2015-07-07 06:11:19 -0700 | [diff] [blame] | 197 | #ifdef WRAP_BITMAP_AS_IMAGE |
| 198 | // TODO: need a way to support the flags for images... |
| 199 | SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bitmap)); |
| 200 | if (image) { |
| 201 | this->onDrawImageRect(image, src, dst, paint); |
| 202 | } |
| 203 | #else |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 204 | TRY_MINIRECORDER(drawBitmapRect, bitmap, src, dst, paint, constraint); |
| 205 | if (kFast_SrcRectConstraint == constraint) { |
| 206 | APPEND(DrawBitmapRectFast, this->copy(paint), bitmap, this->copy(src), dst); |
mtklein | 42ddcd4 | 2014-11-21 08:48:35 -0800 | [diff] [blame] | 207 | return; |
| 208 | } |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 209 | SkASSERT(kStrict_SrcRectConstraint == constraint); |
| 210 | APPEND(DrawBitmapRect, this->copy(paint), bitmap, this->copy(src), dst); |
reed | 5617900 | 2015-07-07 06:11:19 -0700 | [diff] [blame] | 211 | #endif |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 212 | } |
| 213 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 214 | void SkRecorder::onDrawBitmapNine(const SkBitmap& bitmap, |
| 215 | const SkIRect& center, |
| 216 | const SkRect& dst, |
| 217 | const SkPaint* paint) { |
reed | 5617900 | 2015-07-07 06:11:19 -0700 | [diff] [blame] | 218 | #ifdef WRAP_BITMAP_AS_IMAGE |
| 219 | SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bitmap)); |
| 220 | if (image) { |
| 221 | this->onDrawImageNine(image, center, dst, paint); |
| 222 | } |
| 223 | #else |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 224 | APPEND(DrawBitmapNine, this->copy(paint), bitmap, center, dst); |
reed | 5617900 | 2015-07-07 06:11:19 -0700 | [diff] [blame] | 225 | #endif |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 226 | } |
| 227 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 228 | void SkRecorder::onDrawImage(const SkImage* image, SkScalar left, SkScalar top, |
| 229 | const SkPaint* paint) { |
piotaixr | 6515175 | 2014-10-16 11:58:39 -0700 | [diff] [blame] | 230 | APPEND(DrawImage, this->copy(paint), image, left, top); |
| 231 | } |
| 232 | |
reed | 562fe47 | 2015-07-28 07:35:14 -0700 | [diff] [blame] | 233 | void SkRecorder::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst, |
| 234 | const SkPaint* paint, SrcRectConstraint constraint) { |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame] | 235 | APPEND(DrawImageRect, this->copy(paint), image, this->copy(src), dst, constraint); |
piotaixr | 6515175 | 2014-10-16 11:58:39 -0700 | [diff] [blame] | 236 | } |
| 237 | |
reed | 4c21dc5 | 2015-06-25 12:32:03 -0700 | [diff] [blame] | 238 | void SkRecorder::onDrawImageNine(const SkImage* image, const SkIRect& center, |
| 239 | const SkRect& dst, const SkPaint* paint) { |
| 240 | APPEND(DrawImageNine, this->copy(paint), image, center, dst); |
| 241 | } |
| 242 | |
reed@google.com | e0d9ce8 | 2014-04-23 04:00:17 +0000 | [diff] [blame] | 243 | void SkRecorder::onDrawText(const void* text, size_t byteLength, |
| 244 | SkScalar x, SkScalar y, const SkPaint& paint) { |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 245 | APPEND(DrawText, |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 246 | paint, this->copy((const char*)text, byteLength), byteLength, x, y); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 247 | } |
| 248 | |
reed@google.com | e0d9ce8 | 2014-04-23 04:00:17 +0000 | [diff] [blame] | 249 | void SkRecorder::onDrawPosText(const void* text, size_t byteLength, |
| 250 | const SkPoint pos[], const SkPaint& paint) { |
mtklein | c6ad06a | 2015-08-19 09:51:00 -0700 | [diff] [blame] | 251 | const int points = paint.countText(text, byteLength); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 252 | APPEND(DrawPosText, |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 253 | paint, |
commit-bot@chromium.org | 37f6e62 | 2014-05-07 22:59:38 +0000 | [diff] [blame] | 254 | this->copy((const char*)text, byteLength), |
| 255 | byteLength, |
| 256 | this->copy(pos, points)); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 257 | } |
| 258 | |
reed@google.com | e0d9ce8 | 2014-04-23 04:00:17 +0000 | [diff] [blame] | 259 | void SkRecorder::onDrawPosTextH(const void* text, size_t byteLength, |
| 260 | const SkScalar xpos[], SkScalar constY, const SkPaint& paint) { |
mtklein | c6ad06a | 2015-08-19 09:51:00 -0700 | [diff] [blame] | 261 | const int points = paint.countText(text, byteLength); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 262 | APPEND(DrawPosTextH, |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 263 | paint, |
commit-bot@chromium.org | 37f6e62 | 2014-05-07 22:59:38 +0000 | [diff] [blame] | 264 | this->copy((const char*)text, byteLength), |
mtklein | 42ddcd4 | 2014-11-21 08:48:35 -0800 | [diff] [blame] | 265 | SkToUInt(byteLength), |
| 266 | constY, |
| 267 | this->copy(xpos, points)); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 268 | } |
| 269 | |
reed@google.com | e0d9ce8 | 2014-04-23 04:00:17 +0000 | [diff] [blame] | 270 | void SkRecorder::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path, |
| 271 | const SkMatrix* matrix, const SkPaint& paint) { |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 272 | APPEND(DrawTextOnPath, |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 273 | paint, |
commit-bot@chromium.org | 37f6e62 | 2014-05-07 22:59:38 +0000 | [diff] [blame] | 274 | this->copy((const char*)text, byteLength), |
| 275 | byteLength, |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 276 | path, |
mtklein | af57903 | 2014-12-01 11:03:37 -0800 | [diff] [blame] | 277 | matrix ? *matrix : SkMatrix::I()); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 278 | } |
| 279 | |
fmalita | 00d5c2c | 2014-08-21 08:53:26 -0700 | [diff] [blame] | 280 | void SkRecorder::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, |
| 281 | const SkPaint& paint) { |
mtklein | 9db912c | 2015-05-19 11:11:26 -0700 | [diff] [blame] | 282 | TRY_MINIRECORDER(drawTextBlob, blob, x, y, paint); |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 283 | APPEND(DrawTextBlob, paint, blob, x, y); |
fmalita | 00d5c2c | 2014-08-21 08:53:26 -0700 | [diff] [blame] | 284 | } |
| 285 | |
reed | d5fa1a4 | 2014-08-09 11:08:05 -0700 | [diff] [blame] | 286 | void SkRecorder::onDrawPicture(const SkPicture* pic, const SkMatrix* matrix, const SkPaint* paint) { |
mtklein | d711d11 | 2015-07-01 07:04:37 -0700 | [diff] [blame] | 287 | if (fDrawPictureMode == Record_DrawPictureMode) { |
| 288 | fApproxBytesUsedBySubPictures += SkPictureUtils::ApproximateBytesUsed(pic); |
| 289 | APPEND(DrawPicture, this->copy(paint), pic, matrix ? *matrix : SkMatrix::I()); |
| 290 | } else { |
| 291 | SkASSERT(fDrawPictureMode == Playback_DrawPictureMode); |
| 292 | SkAutoCanvasMatrixPaint acmp(this, matrix, paint, pic->cullRect()); |
| 293 | pic->playback(this); |
| 294 | } |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 295 | } |
| 296 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 297 | void SkRecorder::onDrawVertices(VertexMode vmode, |
| 298 | int vertexCount, const SkPoint vertices[], |
| 299 | const SkPoint texs[], const SkColor colors[], |
| 300 | SkXfermode* xmode, |
| 301 | const uint16_t indices[], int indexCount, const SkPaint& paint) { |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 302 | APPEND(DrawVertices, paint, |
commit-bot@chromium.org | 37f6e62 | 2014-05-07 22:59:38 +0000 | [diff] [blame] | 303 | vmode, |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 304 | vertexCount, |
| 305 | this->copy(vertices, vertexCount), |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 306 | texs ? this->copy(texs, vertexCount) : nullptr, |
| 307 | colors ? this->copy(colors, vertexCount) : nullptr, |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 308 | xmode, |
| 309 | this->copy(indices, indexCount), |
commit-bot@chromium.org | 37f6e62 | 2014-05-07 22:59:38 +0000 | [diff] [blame] | 310 | indexCount); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 311 | } |
| 312 | |
dandov | b3c9d1c | 2014-08-12 08:34:29 -0700 | [diff] [blame] | 313 | void SkRecorder::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4], |
| 314 | const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) { |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 315 | APPEND(DrawPatch, paint, |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 316 | cubics ? this->copy(cubics, SkPatchUtils::kNumCtrlPts) : nullptr, |
| 317 | colors ? this->copy(colors, SkPatchUtils::kNumCorners) : nullptr, |
| 318 | texCoords ? this->copy(texCoords, SkPatchUtils::kNumCorners) : nullptr, |
dandov | b3c9d1c | 2014-08-12 08:34:29 -0700 | [diff] [blame] | 319 | xmode); |
dandov | 963137b | 2014-08-07 07:49:53 -0700 | [diff] [blame] | 320 | } |
| 321 | |
reed | 71c3c76 | 2015-06-24 10:29:17 -0700 | [diff] [blame] | 322 | void SkRecorder::onDrawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], |
| 323 | const SkColor colors[], int count, SkXfermode::Mode mode, |
| 324 | const SkRect* cull, const SkPaint* paint) { |
| 325 | APPEND(DrawAtlas, this->copy(paint), |
| 326 | atlas, |
| 327 | this->copy(xform, count), |
| 328 | this->copy(tex, count), |
| 329 | this->copy(colors, count), |
| 330 | count, |
| 331 | mode, |
| 332 | this->copy(cull)); |
| 333 | } |
| 334 | |
Florin Malita | 5f6102d | 2014-06-30 10:13:28 -0400 | [diff] [blame] | 335 | void SkRecorder::willSave() { |
| 336 | APPEND(Save); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 337 | } |
| 338 | |
| 339 | SkCanvas::SaveLayerStrategy SkRecorder::willSaveLayer(const SkRect* bounds, |
| 340 | const SkPaint* paint, |
| 341 | SkCanvas::SaveFlags flags) { |
| 342 | APPEND(SaveLayer, this->copy(bounds), this->copy(paint), flags); |
| 343 | return SkCanvas::kNoLayer_SaveLayerStrategy; |
| 344 | } |
| 345 | |
mtklein | 6cfa73a | 2014-08-13 13:33:49 -0700 | [diff] [blame] | 346 | void SkRecorder::didRestore() { |
mtklein | a723b57 | 2014-08-15 11:49:49 -0700 | [diff] [blame] | 347 | APPEND(Restore, this->devBounds(), this->getTotalMatrix()); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 348 | } |
| 349 | |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 350 | void SkRecorder::didConcat(const SkMatrix& matrix) { |
mtklein | e9d2052 | 2015-11-19 12:08:24 -0800 | [diff] [blame] | 351 | APPEND(Concat, matrix); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 352 | } |
| 353 | |
| 354 | void SkRecorder::didSetMatrix(const SkMatrix& matrix) { |
| 355 | APPEND(SetMatrix, matrix); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 356 | } |
| 357 | |
| 358 | void SkRecorder::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) { |
commit-bot@chromium.org | d9ce2be | 2014-04-09 23:30:28 +0000 | [diff] [blame] | 359 | INHERITED(onClipRect, rect, op, edgeStyle); |
mtklein | cdeeb09 | 2014-11-20 09:14:28 -0800 | [diff] [blame] | 360 | SkRecords::RegionOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle); |
| 361 | APPEND(ClipRect, this->devBounds(), rect, opAA); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 362 | } |
| 363 | |
| 364 | void SkRecorder::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) { |
reed | d954498 | 2014-09-09 18:46:22 -0700 | [diff] [blame] | 365 | INHERITED(onClipRRect, rrect, op, edgeStyle); |
mtklein | cdeeb09 | 2014-11-20 09:14:28 -0800 | [diff] [blame] | 366 | SkRecords::RegionOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle); |
| 367 | APPEND(ClipRRect, this->devBounds(), rrect, opAA); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 368 | } |
| 369 | |
| 370 | void SkRecorder::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) { |
reed | d954498 | 2014-09-09 18:46:22 -0700 | [diff] [blame] | 371 | INHERITED(onClipPath, path, op, edgeStyle); |
mtklein | cdeeb09 | 2014-11-20 09:14:28 -0800 | [diff] [blame] | 372 | SkRecords::RegionOpAndAA opAA(op, kSoft_ClipEdgeStyle == edgeStyle); |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 373 | APPEND(ClipPath, this->devBounds(), path, opAA); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 374 | } |
| 375 | |
| 376 | void SkRecorder::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) { |
commit-bot@chromium.org | d9ce2be | 2014-04-09 23:30:28 +0000 | [diff] [blame] | 377 | INHERITED(onClipRegion, deviceRgn, op); |
mtklein | c845fa0 | 2015-06-30 09:49:49 -0700 | [diff] [blame] | 378 | APPEND(ClipRegion, this->devBounds(), deviceRgn, op); |
commit-bot@chromium.org | e3ff558 | 2014-04-01 16:24:06 +0000 | [diff] [blame] | 379 | } |
mtklein | 5f0e822 | 2014-08-22 11:44:26 -0700 | [diff] [blame] | 380 | |