junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 1 | |
| 2 | /* |
junov@chromium.org | baa0220 | 2013-01-24 14:38:23 +0000 | [diff] [blame] | 3 | * Copyright 2013 Google Inc. |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 4 | * |
| 5 | * Use of this source code is governed by a BSD-style license that can be |
| 6 | * found in the LICENSE file. |
| 7 | */ |
| 8 | |
| 9 | #include "SkDeferredCanvas.h" |
| 10 | |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 11 | #include "SkChunkAlloc.h" |
| 12 | #include "SkColorFilter.h" |
robertphillips | 9a53fd7 | 2015-06-22 09:46:59 -0700 | [diff] [blame] | 13 | #include "SkDevice.h" |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 14 | #include "SkDrawFilter.h" |
| 15 | #include "SkGPipe.h" |
bsalomon | 5581236 | 2015-06-10 08:49:28 -0700 | [diff] [blame] | 16 | #include "SkImage_Base.h" |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 17 | #include "SkPaint.h" |
junov@chromium.org | baa0220 | 2013-01-24 14:38:23 +0000 | [diff] [blame] | 18 | #include "SkPaintPriv.h" |
reed@google.com | 4ed0fb7 | 2012-12-12 20:48:18 +0000 | [diff] [blame] | 19 | #include "SkRRect.h" |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 20 | #include "SkShader.h" |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 21 | #include "SkSurface.h" |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 22 | |
junov@chromium.org | bfeddae | 2012-07-23 13:35:14 +0000 | [diff] [blame] | 23 | enum { |
| 24 | // Deferred canvas will auto-flush when recording reaches this limit |
| 25 | kDefaultMaxRecordingStorageBytes = 64*1024*1024, |
reed@google.com | 140d728 | 2013-01-07 20:25:04 +0000 | [diff] [blame] | 26 | kDeferredCanvasBitmapSizeThreshold = ~0U, // Disables this feature |
junov | 3fcc125 | 2014-12-15 11:34:06 -0800 | [diff] [blame] | 27 | |
| 28 | kNoSaveLayerIndex = -1, |
junov@chromium.org | bfeddae | 2012-07-23 13:35:14 +0000 | [diff] [blame] | 29 | }; |
| 30 | |
junov@chromium.org | eeaf47f | 2012-09-20 20:42:44 +0000 | [diff] [blame] | 31 | enum PlaybackMode { |
| 32 | kNormal_PlaybackMode, |
| 33 | kSilent_PlaybackMode, |
| 34 | }; |
| 35 | |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 36 | static uint64_t image_area(const SkImage* image) { |
| 37 | return sk_64_mul(image->width(), image->height()); |
| 38 | } |
| 39 | |
| 40 | // HACK -- see crbug.com/485243 |
| 41 | // |
| 42 | // Work around case where Blink gives us an image, but will "mutate" it (by changing its contents |
| 43 | // directly using webgl). Until that is fixed at the call-site, we treat gpu-backed-images as |
| 44 | // mutable for now (at least for the purposes of deferred canvas) |
| 45 | // |
| 46 | static bool should_draw_gpu_image_immediately(const SkImage* image) { |
bsalomon | 5581236 | 2015-06-10 08:49:28 -0700 | [diff] [blame] | 47 | return as_IB(image)->getTexture() != NULL; |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 48 | } |
| 49 | |
| 50 | static bool should_draw_immediately(const SkBitmap* bitmap, const SkImage* image, |
| 51 | const SkPaint* paint, size_t bitmapSizeThreshold) { |
sugoi@google.com | 7775fd5 | 2012-11-21 15:47:04 +0000 | [diff] [blame] | 52 | if (bitmap && ((bitmap->getTexture() && !bitmap->isImmutable()) || |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 53 | (bitmap->getSize() > bitmapSizeThreshold))) { |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 54 | return true; |
| 55 | } |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 56 | if (image) { |
| 57 | if (should_draw_gpu_image_immediately(image) || image_area(image) > bitmapSizeThreshold) { |
| 58 | return true; |
| 59 | } |
| 60 | } |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 61 | if (paint) { |
| 62 | SkShader* shader = paint->getShader(); |
| 63 | // Here we detect the case where the shader is an SkBitmapProcShader |
| 64 | // with a gpu texture attached. Checking this without RTTI |
| 65 | // requires making the assumption that only gradient shaders |
| 66 | // and SkBitmapProcShader implement asABitmap(). The following |
| 67 | // code may need to be revised if that assumption is ever broken. |
| 68 | if (shader && !shader->asAGradient(NULL)) { |
| 69 | SkBitmap bm; |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 70 | if (shader->asABitmap(&bm, NULL, NULL) && |
bsalomon | 49f085d | 2014-09-05 13:34:00 -0700 | [diff] [blame] | 71 | bm.getTexture()) { |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 72 | return true; |
| 73 | } |
| 74 | } |
| 75 | } |
| 76 | return false; |
junov@chromium.org | b10a6bd | 2012-07-25 17:27:13 +0000 | [diff] [blame] | 77 | } |
junov@chromium.org | b10a6bd | 2012-07-25 17:27:13 +0000 | [diff] [blame] | 78 | |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 79 | //----------------------------------------------------------------------------- |
| 80 | // DeferredPipeController |
| 81 | //----------------------------------------------------------------------------- |
| 82 | |
| 83 | class DeferredPipeController : public SkGPipeController { |
| 84 | public: |
| 85 | DeferredPipeController(); |
| 86 | void setPlaybackCanvas(SkCanvas*); |
| 87 | virtual ~DeferredPipeController(); |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 88 | void* requestBlock(size_t minRequest, size_t* actual) override; |
| 89 | void notifyWritten(size_t bytes) override; |
junov@chromium.org | fb10389 | 2012-09-20 19:35:43 +0000 | [diff] [blame] | 90 | void playback(bool silent); |
robertphillips | a9061de | 2015-02-27 08:31:57 -0800 | [diff] [blame] | 91 | bool hasPendingCommands() const { return fAllocator.totalUsed() != 0; } |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 92 | size_t storageAllocatedForRecording() const { return fAllocator.totalCapacity(); } |
| 93 | private: |
| 94 | enum { |
| 95 | kMinBlockSize = 4096 |
| 96 | }; |
| 97 | struct PipeBlock { |
| 98 | PipeBlock(void* block, size_t size) { fBlock = block, fSize = size; } |
| 99 | void* fBlock; |
| 100 | size_t fSize; |
| 101 | }; |
| 102 | void* fBlock; |
| 103 | size_t fBytesWritten; |
| 104 | SkChunkAlloc fAllocator; |
| 105 | SkTDArray<PipeBlock> fBlockList; |
| 106 | SkGPipeReader fReader; |
| 107 | }; |
| 108 | |
| 109 | DeferredPipeController::DeferredPipeController() : |
| 110 | fAllocator(kMinBlockSize) { |
| 111 | fBlock = NULL; |
| 112 | fBytesWritten = 0; |
| 113 | } |
| 114 | |
| 115 | DeferredPipeController::~DeferredPipeController() { |
| 116 | fAllocator.reset(); |
| 117 | } |
| 118 | |
| 119 | void DeferredPipeController::setPlaybackCanvas(SkCanvas* canvas) { |
| 120 | fReader.setCanvas(canvas); |
| 121 | } |
| 122 | |
| 123 | void* DeferredPipeController::requestBlock(size_t minRequest, size_t *actual) { |
| 124 | if (fBlock) { |
| 125 | // Save the previous block for later |
| 126 | PipeBlock previousBloc(fBlock, fBytesWritten); |
| 127 | fBlockList.push(previousBloc); |
| 128 | } |
robertphillips@google.com | adacc70 | 2013-10-14 21:53:24 +0000 | [diff] [blame] | 129 | size_t blockSize = SkTMax<size_t>(minRequest, kMinBlockSize); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 130 | fBlock = fAllocator.allocThrow(blockSize); |
| 131 | fBytesWritten = 0; |
| 132 | *actual = blockSize; |
| 133 | return fBlock; |
| 134 | } |
| 135 | |
| 136 | void DeferredPipeController::notifyWritten(size_t bytes) { |
| 137 | fBytesWritten += bytes; |
| 138 | } |
| 139 | |
junov@chromium.org | fb10389 | 2012-09-20 19:35:43 +0000 | [diff] [blame] | 140 | void DeferredPipeController::playback(bool silent) { |
| 141 | uint32_t flags = silent ? SkGPipeReader::kSilent_PlaybackFlag : 0; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 142 | for (int currentBlock = 0; currentBlock < fBlockList.count(); currentBlock++ ) { |
junov@chromium.org | fb10389 | 2012-09-20 19:35:43 +0000 | [diff] [blame] | 143 | fReader.playback(fBlockList[currentBlock].fBlock, fBlockList[currentBlock].fSize, |
| 144 | flags); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 145 | } |
| 146 | fBlockList.reset(); |
| 147 | |
| 148 | if (fBlock) { |
junov@chromium.org | fb10389 | 2012-09-20 19:35:43 +0000 | [diff] [blame] | 149 | fReader.playback(fBlock, fBytesWritten, flags); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 150 | fBlock = NULL; |
| 151 | } |
| 152 | |
| 153 | // Release all allocated blocks |
| 154 | fAllocator.reset(); |
junov | d26c9fa | 2015-06-02 11:47:45 -0700 | [diff] [blame] | 155 | |
| 156 | this->purgeCaches(); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 157 | } |
| 158 | |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 159 | //----------------------------------------------------------------------------- |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 160 | // SkDeferredDevice |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 161 | //----------------------------------------------------------------------------- |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 162 | class SkDeferredDevice : public SkBaseDevice { |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 163 | public: |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 164 | explicit SkDeferredDevice(SkSurface* surface); |
| 165 | ~SkDeferredDevice(); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 166 | |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 167 | void setNotificationClient(SkDeferredCanvas::NotificationClient* notificationClient); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 168 | SkCanvas* recordingCanvas(); |
| 169 | SkCanvas* immediateCanvas() const {return fImmediateCanvas;} |
robertphillips@google.com | 1f2f338 | 2013-08-29 11:54:56 +0000 | [diff] [blame] | 170 | SkBaseDevice* immediateDevice() const {return fImmediateCanvas->getTopDevice();} |
junov@chromium.org | 5ee449a | 2013-04-12 20:20:50 +0000 | [diff] [blame] | 171 | SkImage* newImageSnapshot(); |
junov@chromium.org | 7070f76 | 2013-05-24 17:13:00 +0000 | [diff] [blame] | 172 | void setSurface(SkSurface* surface); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 173 | bool isFreshFrame(); |
junov@chromium.org | a38dfb6 | 2012-09-20 22:10:33 +0000 | [diff] [blame] | 174 | bool hasPendingCommands(); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 175 | size_t storageAllocatedForRecording() const; |
| 176 | size_t freeMemoryIfPossible(size_t bytesToFree); |
junov@chromium.org | eeaf47f | 2012-09-20 20:42:44 +0000 | [diff] [blame] | 177 | void flushPendingCommands(PlaybackMode); |
junov@chromium.org | 0a67f96 | 2012-09-19 22:48:34 +0000 | [diff] [blame] | 178 | void skipPendingCommands(); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 179 | void setMaxRecordingStorage(size_t); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 180 | void recordedDrawCommand(); |
junov | 3fcc125 | 2014-12-15 11:34:06 -0800 | [diff] [blame] | 181 | void setIsDrawingToLayer(bool value) {fIsDrawingToLayer = value;} |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 182 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 183 | SkImageInfo imageInfo() const override; |
reed@google.com | 284a84d | 2014-02-14 15:23:15 +0000 | [diff] [blame] | 184 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 185 | GrRenderTarget* accessRenderTarget() override; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 186 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 187 | SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 188 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 189 | SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) override; |
reed@google.com | 76f10a3 | 2014-02-05 15:32:21 +0000 | [diff] [blame] | 190 | |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 191 | protected: |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 192 | const SkBitmap& onAccessBitmap() override; |
| 193 | bool onReadPixels(const SkImageInfo&, void*, size_t, int x, int y) override; |
| 194 | bool onWritePixels(const SkImageInfo&, const void*, size_t, int x, int y) override; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 195 | |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 196 | // None of the following drawing methods should ever get called on the |
| 197 | // deferred device |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 198 | void drawPaint(const SkDraw&, const SkPaint& paint) override |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 199 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 200 | void drawPoints(const SkDraw&, SkCanvas::PointMode mode, |
| 201 | size_t count, const SkPoint[], |
| 202 | const SkPaint& paint) override |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 203 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 204 | void drawRect(const SkDraw&, const SkRect& r, |
| 205 | const SkPaint& paint) override |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 206 | {SkASSERT(0);} |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 207 | void drawOval(const SkDraw&, const SkRect&, const SkPaint&) override |
reed@google.com | 284a84d | 2014-02-14 15:23:15 +0000 | [diff] [blame] | 208 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 209 | void drawRRect(const SkDraw&, const SkRRect& rr, |
| 210 | const SkPaint& paint) override |
reed@google.com | 284a84d | 2014-02-14 15:23:15 +0000 | [diff] [blame] | 211 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 212 | void drawPath(const SkDraw&, const SkPath& path, |
| 213 | const SkPaint& paint, |
| 214 | const SkMatrix* prePathMatrix = NULL, |
| 215 | bool pathIsMutable = false) override |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 216 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 217 | void drawBitmap(const SkDraw&, const SkBitmap& bitmap, |
| 218 | const SkMatrix& matrix, const SkPaint& paint) override |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 219 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 220 | void drawBitmapRect(const SkDraw&, const SkBitmap&, const SkRect*, |
| 221 | const SkRect&, const SkPaint&, |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame^] | 222 | SK_VIRTUAL_CONSTRAINT_TYPE) override |
reed@google.com | 284a84d | 2014-02-14 15:23:15 +0000 | [diff] [blame] | 223 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 224 | void drawSprite(const SkDraw&, const SkBitmap& bitmap, |
| 225 | int x, int y, const SkPaint& paint) override |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 226 | {SkASSERT(0);} |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 227 | void drawImage(const SkDraw&, const SkImage*, SkScalar, SkScalar, const SkPaint&) override |
| 228 | {SkASSERT(0);} |
| 229 | void drawImageRect(const SkDraw&, const SkImage*, const SkRect*, const SkRect&, |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame^] | 230 | const SkPaint&, SkCanvas::SrcRectConstraint) override |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 231 | {SkASSERT(0);} |
reed | 4c21dc5 | 2015-06-25 12:32:03 -0700 | [diff] [blame] | 232 | void drawImageNine(const SkDraw&, const SkImage*, const SkIRect&, const SkRect&, |
| 233 | const SkPaint&) override |
| 234 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 235 | void drawText(const SkDraw&, const void* text, size_t len, |
| 236 | SkScalar x, SkScalar y, const SkPaint& paint) override |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 237 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 238 | void drawPosText(const SkDraw&, const void* text, size_t len, |
| 239 | const SkScalar pos[], int scalarsPerPos, |
| 240 | const SkPoint& offset, const SkPaint& paint) override |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 241 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 242 | void drawTextOnPath(const SkDraw&, const void* text, |
| 243 | size_t len, const SkPath& path, |
| 244 | const SkMatrix* matrix, |
| 245 | const SkPaint& paint) override |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 246 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 247 | void drawVertices(const SkDraw&, SkCanvas::VertexMode, |
| 248 | int vertexCount, const SkPoint verts[], |
| 249 | const SkPoint texs[], const SkColor colors[], |
| 250 | SkXfermode* xmode, const uint16_t indices[], |
| 251 | int indexCount, const SkPaint& paint) override |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 252 | {SkASSERT(0);} |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 253 | void drawPatch(const SkDraw&, const SkPoint cubics[12], const SkColor colors[4], |
| 254 | const SkPoint texCoords[4], SkXfermode* xmode, |
| 255 | const SkPaint& paint) override |
dandov | ecfff21 | 2014-08-04 10:02:00 -0700 | [diff] [blame] | 256 | {SkASSERT(0);} |
reed | 71c3c76 | 2015-06-24 10:29:17 -0700 | [diff] [blame] | 257 | void drawAtlas(const SkDraw&, const SkImage* atlas, const SkRSXform[], const SkRect[], |
| 258 | const SkColor[], int count, SkXfermode::Mode, const SkPaint&) override |
| 259 | {SkASSERT(0);} |
| 260 | |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 261 | void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y, |
| 262 | const SkPaint&) override |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 263 | {SkASSERT(0);} |
reed@google.com | 284a84d | 2014-02-14 15:23:15 +0000 | [diff] [blame] | 264 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 265 | bool canHandleImageFilter(const SkImageFilter*) override { |
reed@google.com | 284a84d | 2014-02-14 15:23:15 +0000 | [diff] [blame] | 266 | return false; |
| 267 | } |
tfarina | 283b587 | 2015-04-25 12:59:44 -0700 | [diff] [blame] | 268 | bool filterImage(const SkImageFilter*, const SkBitmap&, |
| 269 | const SkImageFilter::Context&, SkBitmap*, SkIPoint*) override { |
reed@google.com | 284a84d | 2014-02-14 15:23:15 +0000 | [diff] [blame] | 270 | return false; |
| 271 | } |
| 272 | |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 273 | private: |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 274 | void flush() override; |
| 275 | void replaceBitmapBackendForRasterSurface(const SkBitmap&) override {} |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 276 | |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 277 | void beginRecording(); |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 278 | void init(); |
junov@chromium.org | 44324fa | 2013-08-02 15:36:02 +0000 | [diff] [blame] | 279 | void aboutToDraw(); |
| 280 | void prepareForImmediatePixelWrite(); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 281 | |
| 282 | DeferredPipeController fPipeController; |
| 283 | SkGPipeWriter fPipeWriter; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 284 | SkCanvas* fImmediateCanvas; |
| 285 | SkCanvas* fRecordingCanvas; |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 286 | SkSurface* fSurface; |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 287 | SkDeferredCanvas::NotificationClient* fNotificationClient; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 288 | bool fFreshFrame; |
commit-bot@chromium.org | c4c9870 | 2013-04-22 14:28:01 +0000 | [diff] [blame] | 289 | bool fCanDiscardCanvasContents; |
junov | 3fcc125 | 2014-12-15 11:34:06 -0800 | [diff] [blame] | 290 | bool fIsDrawingToLayer; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 291 | size_t fMaxRecordingStorageBytes; |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 292 | size_t fPreviousStorageAllocated; |
robertphillips | 9a53fd7 | 2015-06-22 09:46:59 -0700 | [diff] [blame] | 293 | |
| 294 | typedef SkBaseDevice INHERITED; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 295 | }; |
| 296 | |
robertphillips | 9a53fd7 | 2015-06-22 09:46:59 -0700 | [diff] [blame] | 297 | SkDeferredDevice::SkDeferredDevice(SkSurface* surface) |
| 298 | : INHERITED(surface->props()) { |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 299 | fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes; |
| 300 | fNotificationClient = NULL; |
junov@chromium.org | 7070f76 | 2013-05-24 17:13:00 +0000 | [diff] [blame] | 301 | fImmediateCanvas = NULL; |
| 302 | fSurface = NULL; |
| 303 | this->setSurface(surface); |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 304 | this->init(); |
| 305 | } |
| 306 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 307 | void SkDeferredDevice::setSurface(SkSurface* surface) { |
junov@chromium.org | 7070f76 | 2013-05-24 17:13:00 +0000 | [diff] [blame] | 308 | SkRefCnt_SafeAssign(fImmediateCanvas, surface->getCanvas()); |
| 309 | SkRefCnt_SafeAssign(fSurface, surface); |
| 310 | fPipeController.setPlaybackCanvas(fImmediateCanvas); |
| 311 | } |
| 312 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 313 | void SkDeferredDevice::init() { |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 314 | fRecordingCanvas = NULL; |
| 315 | fFreshFrame = true; |
junov | 3fcc125 | 2014-12-15 11:34:06 -0800 | [diff] [blame] | 316 | fIsDrawingToLayer = false; |
commit-bot@chromium.org | c4c9870 | 2013-04-22 14:28:01 +0000 | [diff] [blame] | 317 | fCanDiscardCanvasContents = false; |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 318 | fPreviousStorageAllocated = 0; |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 319 | fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes; |
| 320 | fNotificationClient = NULL; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 321 | this->beginRecording(); |
| 322 | } |
| 323 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 324 | SkDeferredDevice::~SkDeferredDevice() { |
junov@chromium.org | eeaf47f | 2012-09-20 20:42:44 +0000 | [diff] [blame] | 325 | this->flushPendingCommands(kSilent_PlaybackMode); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 326 | SkSafeUnref(fImmediateCanvas); |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 327 | SkSafeUnref(fSurface); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 328 | } |
| 329 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 330 | void SkDeferredDevice::setMaxRecordingStorage(size_t maxStorage) { |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 331 | fMaxRecordingStorageBytes = maxStorage; |
| 332 | this->recordingCanvas(); // Accessing the recording canvas applies the new limit. |
| 333 | } |
| 334 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 335 | void SkDeferredDevice::beginRecording() { |
junov@chromium.org | a8db8fe | 2012-08-15 19:49:22 +0000 | [diff] [blame] | 336 | SkASSERT(NULL == fRecordingCanvas); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 337 | fRecordingCanvas = fPipeWriter.startRecording(&fPipeController, 0, |
junov@chromium.org | 9becf00 | 2013-04-15 18:15:23 +0000 | [diff] [blame] | 338 | immediateDevice()->width(), immediateDevice()->height()); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 339 | } |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 340 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 341 | void SkDeferredDevice::setNotificationClient( |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 342 | SkDeferredCanvas::NotificationClient* notificationClient) { |
junov@chromium.org | 5280548 | 2012-08-20 14:25:04 +0000 | [diff] [blame] | 343 | fNotificationClient = notificationClient; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 344 | } |
| 345 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 346 | void SkDeferredDevice::skipPendingCommands() { |
junov | 3fcc125 | 2014-12-15 11:34:06 -0800 | [diff] [blame] | 347 | if (!fIsDrawingToLayer) { |
commit-bot@chromium.org | c4c9870 | 2013-04-22 14:28:01 +0000 | [diff] [blame] | 348 | fCanDiscardCanvasContents = true; |
| 349 | if (fPipeController.hasPendingCommands()) { |
| 350 | fFreshFrame = true; |
| 351 | flushPendingCommands(kSilent_PlaybackMode); |
junov@google.com | 52a00ca | 2012-10-01 15:27:14 +0000 | [diff] [blame] | 352 | } |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 353 | } |
| 354 | } |
| 355 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 356 | bool SkDeferredDevice::isFreshFrame() { |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 357 | bool ret = fFreshFrame; |
| 358 | fFreshFrame = false; |
| 359 | return ret; |
| 360 | } |
| 361 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 362 | bool SkDeferredDevice::hasPendingCommands() { |
junov@chromium.org | a38dfb6 | 2012-09-20 22:10:33 +0000 | [diff] [blame] | 363 | return fPipeController.hasPendingCommands(); |
| 364 | } |
| 365 | |
reed | 71c3c76 | 2015-06-24 10:29:17 -0700 | [diff] [blame] | 366 | void SkDeferredDevice::aboutToDraw() { |
bsalomon | 49f085d | 2014-09-05 13:34:00 -0700 | [diff] [blame] | 367 | if (fNotificationClient) { |
junov@chromium.org | 44324fa | 2013-08-02 15:36:02 +0000 | [diff] [blame] | 368 | fNotificationClient->prepareForDraw(); |
| 369 | } |
| 370 | if (fCanDiscardCanvasContents) { |
bsalomon | 49f085d | 2014-09-05 13:34:00 -0700 | [diff] [blame] | 371 | if (fSurface) { |
junov@chromium.org | 44324fa | 2013-08-02 15:36:02 +0000 | [diff] [blame] | 372 | fSurface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode); |
| 373 | } |
skia.committer@gmail.com | ea4b797 | 2013-08-06 07:01:27 +0000 | [diff] [blame] | 374 | fCanDiscardCanvasContents = false; |
junov@chromium.org | 44324fa | 2013-08-02 15:36:02 +0000 | [diff] [blame] | 375 | } |
| 376 | } |
| 377 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 378 | void SkDeferredDevice::flushPendingCommands(PlaybackMode playbackMode) { |
junov@chromium.org | a38dfb6 | 2012-09-20 22:10:33 +0000 | [diff] [blame] | 379 | if (!fPipeController.hasPendingCommands()) { |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 380 | return; |
| 381 | } |
commit-bot@chromium.org | c4c9870 | 2013-04-22 14:28:01 +0000 | [diff] [blame] | 382 | if (playbackMode == kNormal_PlaybackMode) { |
junov@chromium.org | 44324fa | 2013-08-02 15:36:02 +0000 | [diff] [blame] | 383 | aboutToDraw(); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 384 | } |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 385 | fPipeWriter.flushRecording(true); |
junov@chromium.org | d4501a0 | 2012-10-30 19:05:17 +0000 | [diff] [blame] | 386 | fPipeController.playback(kSilent_PlaybackMode == playbackMode); |
commit-bot@chromium.org | dad009b | 2014-03-27 15:48:52 +0000 | [diff] [blame] | 387 | if (fNotificationClient) { |
| 388 | if (playbackMode == kSilent_PlaybackMode) { |
| 389 | fNotificationClient->skippedPendingDrawCommands(); |
| 390 | } else { |
| 391 | fNotificationClient->flushedDrawCommands(); |
| 392 | } |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 393 | } |
commit-bot@chromium.org | dad009b | 2014-03-27 15:48:52 +0000 | [diff] [blame] | 394 | |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 395 | fPreviousStorageAllocated = storageAllocatedForRecording(); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 396 | } |
| 397 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 398 | void SkDeferredDevice::flush() { |
junov@chromium.org | eeaf47f | 2012-09-20 20:42:44 +0000 | [diff] [blame] | 399 | this->flushPendingCommands(kNormal_PlaybackMode); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 400 | fImmediateCanvas->flush(); |
| 401 | } |
| 402 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 403 | size_t SkDeferredDevice::freeMemoryIfPossible(size_t bytesToFree) { |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 404 | size_t val = fPipeWriter.freeMemoryIfPossible(bytesToFree); |
| 405 | fPreviousStorageAllocated = storageAllocatedForRecording(); |
| 406 | return val; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 407 | } |
| 408 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 409 | size_t SkDeferredDevice::storageAllocatedForRecording() const { |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 410 | return (fPipeController.storageAllocatedForRecording() |
| 411 | + fPipeWriter.storageAllocatedForRecording()); |
| 412 | } |
| 413 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 414 | void SkDeferredDevice::recordedDrawCommand() { |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 415 | size_t storageAllocated = this->storageAllocatedForRecording(); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 416 | |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 417 | if (storageAllocated > fMaxRecordingStorageBytes) { |
| 418 | // First, attempt to reduce cache without flushing |
| 419 | size_t tryFree = storageAllocated - fMaxRecordingStorageBytes; |
| 420 | if (this->freeMemoryIfPossible(tryFree) < tryFree) { |
| 421 | // Flush is necessary to free more space. |
junov@chromium.org | eeaf47f | 2012-09-20 20:42:44 +0000 | [diff] [blame] | 422 | this->flushPendingCommands(kNormal_PlaybackMode); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 423 | // Free as much as possible to avoid oscillating around fMaxRecordingStorageBytes |
| 424 | // which could cause a high flushing frequency. |
bsalomon@google.com | 100abf4 | 2012-09-05 17:40:04 +0000 | [diff] [blame] | 425 | this->freeMemoryIfPossible(~0U); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 426 | } |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 427 | storageAllocated = this->storageAllocatedForRecording(); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 428 | } |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 429 | |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 430 | if (fNotificationClient && |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 431 | storageAllocated != fPreviousStorageAllocated) { |
| 432 | fPreviousStorageAllocated = storageAllocated; |
| 433 | fNotificationClient->storageAllocatedForRecordingChanged(storageAllocated); |
| 434 | } |
| 435 | } |
| 436 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 437 | SkCanvas* SkDeferredDevice::recordingCanvas() { |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 438 | return fRecordingCanvas; |
| 439 | } |
| 440 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 441 | SkImage* SkDeferredDevice::newImageSnapshot() { |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 442 | this->flush(); |
junov@chromium.org | 5ee449a | 2013-04-12 20:20:50 +0000 | [diff] [blame] | 443 | return fSurface ? fSurface->newImageSnapshot() : NULL; |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 444 | } |
| 445 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 446 | SkImageInfo SkDeferredDevice::imageInfo() const { |
reed@google.com | 284a84d | 2014-02-14 15:23:15 +0000 | [diff] [blame] | 447 | return immediateDevice()->imageInfo(); |
| 448 | } |
| 449 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 450 | GrRenderTarget* SkDeferredDevice::accessRenderTarget() { |
junov@chromium.org | eeaf47f | 2012-09-20 20:42:44 +0000 | [diff] [blame] | 451 | this->flushPendingCommands(kNormal_PlaybackMode); |
junov@chromium.org | 9becf00 | 2013-04-15 18:15:23 +0000 | [diff] [blame] | 452 | return immediateDevice()->accessRenderTarget(); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 453 | } |
| 454 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 455 | void SkDeferredDevice::prepareForImmediatePixelWrite() { |
junov@chromium.org | 44324fa | 2013-08-02 15:36:02 +0000 | [diff] [blame] | 456 | // The purpose of the following code is to make sure commands are flushed, that |
| 457 | // aboutToDraw() is called and that notifyContentWillChange is called, without |
| 458 | // calling anything redundantly. |
| 459 | if (fPipeController.hasPendingCommands()) { |
| 460 | this->flushPendingCommands(kNormal_PlaybackMode); |
| 461 | } else { |
| 462 | bool mustNotifyDirectly = !fCanDiscardCanvasContents; |
| 463 | this->aboutToDraw(); |
| 464 | if (mustNotifyDirectly) { |
| 465 | fSurface->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode); |
| 466 | } |
| 467 | } |
| 468 | |
| 469 | fImmediateCanvas->flush(); |
| 470 | } |
| 471 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 472 | bool SkDeferredDevice::onWritePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 473 | int x, int y) { |
| 474 | SkASSERT(x >= 0 && y >= 0); |
| 475 | SkASSERT(x + info.width() <= width()); |
| 476 | SkASSERT(y + info.height() <= height()); |
| 477 | |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 478 | const SkImageInfo deviceInfo = this->imageInfo(); |
| 479 | if (info.width() == deviceInfo.width() && info.height() == deviceInfo.height()) { |
| 480 | this->skipPendingCommands(); |
kkinnunen | 8dcb8b0 | 2015-03-23 02:18:02 -0700 | [diff] [blame] | 481 | } else { |
| 482 | this->flushPendingCommands(kNormal_PlaybackMode); |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 483 | } |
skia.committer@gmail.com | e62513f | 2014-03-08 03:02:06 +0000 | [diff] [blame] | 484 | |
commit-bot@chromium.org | 4cd9e21 | 2014-03-07 03:25:16 +0000 | [diff] [blame] | 485 | this->prepareForImmediatePixelWrite(); |
| 486 | return immediateDevice()->onWritePixels(info, pixels, rowBytes, x, y); |
| 487 | } |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 488 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 489 | const SkBitmap& SkDeferredDevice::onAccessBitmap() { |
junov@chromium.org | eeaf47f | 2012-09-20 20:42:44 +0000 | [diff] [blame] | 490 | this->flushPendingCommands(kNormal_PlaybackMode); |
junov@chromium.org | 9becf00 | 2013-04-15 18:15:23 +0000 | [diff] [blame] | 491 | return immediateDevice()->accessBitmap(false); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 492 | } |
| 493 | |
reed | 76033be | 2015-03-14 10:54:31 -0700 | [diff] [blame] | 494 | SkBaseDevice* SkDeferredDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint* layerPaint) { |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 495 | // Create a compatible non-deferred device. |
junov@chromium.org | b1c725a | 2013-05-21 20:16:17 +0000 | [diff] [blame] | 496 | // We do not create a deferred device because we know the new device |
| 497 | // will not be used with a deferred canvas (there is no API for that). |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 498 | // And connecting a SkDeferredDevice to non-deferred canvas can result |
junov@chromium.org | b1c725a | 2013-05-21 20:16:17 +0000 | [diff] [blame] | 499 | // in unpredictable behavior. |
robertphillips | efbffed | 2015-06-22 12:06:08 -0700 | [diff] [blame] | 500 | return this->immediateDevice()->onCreateDevice(cinfo, layerPaint); |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 501 | } |
| 502 | |
reed | 4a8126e | 2014-09-22 07:29:03 -0700 | [diff] [blame] | 503 | SkSurface* SkDeferredDevice::newSurface(const SkImageInfo& info, const SkSurfaceProps& props) { |
| 504 | return this->immediateDevice()->newSurface(info, props); |
reed@google.com | 76f10a3 | 2014-02-05 15:32:21 +0000 | [diff] [blame] | 505 | } |
| 506 | |
commit-bot@chromium.org | a713f9c | 2014-03-17 21:31:26 +0000 | [diff] [blame] | 507 | bool SkDeferredDevice::onReadPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, |
| 508 | int x, int y) { |
| 509 | this->flushPendingCommands(kNormal_PlaybackMode); |
| 510 | return fImmediateCanvas->readPixels(info, pixels, rowBytes, x, y); |
| 511 | } |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 512 | |
sugoi@google.com | 7775fd5 | 2012-11-21 15:47:04 +0000 | [diff] [blame] | 513 | class AutoImmediateDrawIfNeeded { |
| 514 | public: |
| 515 | AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkBitmap* bitmap, |
| 516 | const SkPaint* paint) { |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 517 | this->init(canvas, bitmap, NULL, paint); |
| 518 | } |
| 519 | AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkImage* image, |
| 520 | const SkPaint* paint) { |
| 521 | this->init(canvas, NULL, image, paint); |
sugoi@google.com | 7775fd5 | 2012-11-21 15:47:04 +0000 | [diff] [blame] | 522 | } |
| 523 | |
| 524 | AutoImmediateDrawIfNeeded(SkDeferredCanvas& canvas, const SkPaint* paint) { |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 525 | this->init(canvas, NULL, NULL, paint); |
sugoi@google.com | 7775fd5 | 2012-11-21 15:47:04 +0000 | [diff] [blame] | 526 | } |
| 527 | |
| 528 | ~AutoImmediateDrawIfNeeded() { |
| 529 | if (fCanvas) { |
| 530 | fCanvas->setDeferredDrawing(true); |
| 531 | } |
| 532 | } |
| 533 | private: |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 534 | void init(SkDeferredCanvas& canvas, const SkBitmap* bitmap, const SkImage* image, |
| 535 | const SkPaint* paint) { |
reed | 52d9ac6 | 2014-06-30 09:05:34 -0700 | [diff] [blame] | 536 | if (canvas.isDeferredDrawing() && |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 537 | should_draw_immediately(bitmap, image, paint, canvas.getBitmapSizeThreshold())) { |
sugoi@google.com | 7775fd5 | 2012-11-21 15:47:04 +0000 | [diff] [blame] | 538 | canvas.setDeferredDrawing(false); |
| 539 | fCanvas = &canvas; |
| 540 | } else { |
| 541 | fCanvas = NULL; |
| 542 | } |
| 543 | } |
| 544 | |
| 545 | SkDeferredCanvas* fCanvas; |
| 546 | }; |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 547 | |
junov@chromium.org | 66070a5 | 2013-05-28 17:39:08 +0000 | [diff] [blame] | 548 | SkDeferredCanvas* SkDeferredCanvas::Create(SkSurface* surface) { |
robertphillips | 9a53fd7 | 2015-06-22 09:46:59 -0700 | [diff] [blame] | 549 | if (!surface) { |
| 550 | return NULL; |
| 551 | } |
| 552 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 553 | SkAutoTUnref<SkDeferredDevice> deferredDevice(SkNEW_ARGS(SkDeferredDevice, (surface))); |
junov@chromium.org | 66070a5 | 2013-05-28 17:39:08 +0000 | [diff] [blame] | 554 | return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice)); |
| 555 | } |
| 556 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 557 | SkDeferredCanvas::SkDeferredCanvas(SkDeferredDevice* device) : SkCanvas (device) { |
junov@chromium.org | 66070a5 | 2013-05-28 17:39:08 +0000 | [diff] [blame] | 558 | this->init(); |
| 559 | } |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 560 | |
junov@chromium.org | c16ca92 | 2012-02-24 22:06:27 +0000 | [diff] [blame] | 561 | void SkDeferredCanvas::init() { |
reed | 52d9ac6 | 2014-06-30 09:05:34 -0700 | [diff] [blame] | 562 | fBitmapSizeThreshold = kDeferredCanvasBitmapSizeThreshold; |
junov@chromium.org | 5e5a095 | 2012-02-28 15:27:59 +0000 | [diff] [blame] | 563 | fDeferredDrawing = true; // On by default |
yunchao.he | 49005bf | 2014-09-15 22:30:38 -0700 | [diff] [blame] | 564 | fCachedCanvasSize.setEmpty(); |
| 565 | fCachedCanvasSizeDirty = true; |
junov | 3fcc125 | 2014-12-15 11:34:06 -0800 | [diff] [blame] | 566 | fSaveLevel = 0; |
| 567 | fFirstSaveLayerIndex = kNoSaveLayerIndex; |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 568 | } |
| 569 | |
junov@chromium.org | bfeddae | 2012-07-23 13:35:14 +0000 | [diff] [blame] | 570 | void SkDeferredCanvas::setMaxRecordingStorage(size_t maxStorage) { |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 571 | this->validate(); |
junov@chromium.org | bfeddae | 2012-07-23 13:35:14 +0000 | [diff] [blame] | 572 | this->getDeferredDevice()->setMaxRecordingStorage(maxStorage); |
| 573 | } |
| 574 | |
junov@chromium.org | 2e14ba8 | 2012-08-07 14:26:57 +0000 | [diff] [blame] | 575 | size_t SkDeferredCanvas::storageAllocatedForRecording() const { |
| 576 | return this->getDeferredDevice()->storageAllocatedForRecording(); |
| 577 | } |
| 578 | |
| 579 | size_t SkDeferredCanvas::freeMemoryIfPossible(size_t bytesToFree) { |
junov@chromium.org | 2e14ba8 | 2012-08-07 14:26:57 +0000 | [diff] [blame] | 580 | return this->getDeferredDevice()->freeMemoryIfPossible(bytesToFree); |
junov@chromium.org | 2e14ba8 | 2012-08-07 14:26:57 +0000 | [diff] [blame] | 581 | } |
| 582 | |
sugoi@google.com | 7775fd5 | 2012-11-21 15:47:04 +0000 | [diff] [blame] | 583 | void SkDeferredCanvas::setBitmapSizeThreshold(size_t sizeThreshold) { |
reed | 52d9ac6 | 2014-06-30 09:05:34 -0700 | [diff] [blame] | 584 | fBitmapSizeThreshold = sizeThreshold; |
sugoi@google.com | 7775fd5 | 2012-11-21 15:47:04 +0000 | [diff] [blame] | 585 | } |
| 586 | |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 587 | void SkDeferredCanvas::recordedDrawCommand() { |
| 588 | if (fDeferredDrawing) { |
| 589 | this->getDeferredDevice()->recordedDrawCommand(); |
| 590 | } |
| 591 | } |
| 592 | |
junov@chromium.org | c16ca92 | 2012-02-24 22:06:27 +0000 | [diff] [blame] | 593 | void SkDeferredCanvas::validate() const { |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 594 | SkASSERT(this->getDevice()); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 595 | } |
| 596 | |
junov@chromium.org | 5e5a095 | 2012-02-28 15:27:59 +0000 | [diff] [blame] | 597 | SkCanvas* SkDeferredCanvas::drawingCanvas() const { |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 598 | this->validate(); |
| 599 | return fDeferredDrawing ? this->getDeferredDevice()->recordingCanvas() : |
| 600 | this->getDeferredDevice()->immediateCanvas(); |
junov@chromium.org | 5e5a095 | 2012-02-28 15:27:59 +0000 | [diff] [blame] | 601 | } |
| 602 | |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 603 | SkCanvas* SkDeferredCanvas::immediateCanvas() const { |
| 604 | this->validate(); |
| 605 | return this->getDeferredDevice()->immediateCanvas(); |
| 606 | } |
| 607 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 608 | SkDeferredDevice* SkDeferredCanvas::getDeferredDevice() const { |
| 609 | return static_cast<SkDeferredDevice*>(this->getDevice()); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 610 | } |
| 611 | |
junov@chromium.org | c16ca92 | 2012-02-24 22:06:27 +0000 | [diff] [blame] | 612 | void SkDeferredCanvas::setDeferredDrawing(bool val) { |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 613 | this->validate(); // Must set device before calling this method |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 614 | if (val != fDeferredDrawing) { |
| 615 | if (fDeferredDrawing) { |
junov@chromium.org | 5e5a095 | 2012-02-28 15:27:59 +0000 | [diff] [blame] | 616 | // Going live. |
junov@chromium.org | eeaf47f | 2012-09-20 20:42:44 +0000 | [diff] [blame] | 617 | this->getDeferredDevice()->flushPendingCommands(kNormal_PlaybackMode); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 618 | } |
| 619 | fDeferredDrawing = val; |
| 620 | } |
| 621 | } |
| 622 | |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 623 | bool SkDeferredCanvas::isDeferredDrawing() const { |
junov@chromium.org | b10a6bd | 2012-07-25 17:27:13 +0000 | [diff] [blame] | 624 | return fDeferredDrawing; |
| 625 | } |
| 626 | |
junov@chromium.org | 88e2914 | 2012-08-07 16:48:22 +0000 | [diff] [blame] | 627 | bool SkDeferredCanvas::isFreshFrame() const { |
| 628 | return this->getDeferredDevice()->isFreshFrame(); |
| 629 | } |
| 630 | |
yunchao.he | 49005bf | 2014-09-15 22:30:38 -0700 | [diff] [blame] | 631 | SkISize SkDeferredCanvas::getCanvasSize() const { |
| 632 | if (fCachedCanvasSizeDirty) { |
| 633 | fCachedCanvasSize = this->getBaseLayerSize(); |
| 634 | fCachedCanvasSizeDirty = false; |
| 635 | } |
| 636 | return fCachedCanvasSize; |
| 637 | } |
| 638 | |
junov@chromium.org | a38dfb6 | 2012-09-20 22:10:33 +0000 | [diff] [blame] | 639 | bool SkDeferredCanvas::hasPendingCommands() const { |
| 640 | return this->getDeferredDevice()->hasPendingCommands(); |
| 641 | } |
| 642 | |
junov@chromium.org | fb10389 | 2012-09-20 19:35:43 +0000 | [diff] [blame] | 643 | void SkDeferredCanvas::silentFlush() { |
| 644 | if (fDeferredDrawing) { |
junov@chromium.org | eeaf47f | 2012-09-20 20:42:44 +0000 | [diff] [blame] | 645 | this->getDeferredDevice()->flushPendingCommands(kSilent_PlaybackMode); |
junov@chromium.org | fb10389 | 2012-09-20 19:35:43 +0000 | [diff] [blame] | 646 | } |
| 647 | } |
| 648 | |
junov@chromium.org | c16ca92 | 2012-02-24 22:06:27 +0000 | [diff] [blame] | 649 | SkDeferredCanvas::~SkDeferredCanvas() { |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 650 | } |
| 651 | |
junov@chromium.org | 7070f76 | 2013-05-24 17:13:00 +0000 | [diff] [blame] | 652 | SkSurface* SkDeferredCanvas::setSurface(SkSurface* surface) { |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 653 | SkDeferredDevice* deferredDevice = this->getDeferredDevice(); |
bsalomon | 49f085d | 2014-09-05 13:34:00 -0700 | [diff] [blame] | 654 | SkASSERT(deferredDevice); |
junov@chromium.org | 66070a5 | 2013-05-28 17:39:08 +0000 | [diff] [blame] | 655 | // By swapping the surface into the existing device, we preserve |
| 656 | // all pending commands, which can help to seamlessly recover from |
| 657 | // a lost accelerated graphics context. |
| 658 | deferredDevice->setSurface(surface); |
yunchao.he | 49005bf | 2014-09-15 22:30:38 -0700 | [diff] [blame] | 659 | fCachedCanvasSizeDirty = true; |
junov@chromium.org | 7070f76 | 2013-05-24 17:13:00 +0000 | [diff] [blame] | 660 | return surface; |
| 661 | } |
| 662 | |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 663 | SkDeferredCanvas::NotificationClient* SkDeferredCanvas::setNotificationClient( |
| 664 | NotificationClient* notificationClient) { |
junov@chromium.org | c16ca92 | 2012-02-24 22:06:27 +0000 | [diff] [blame] | 665 | |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 666 | SkDeferredDevice* deferredDevice = this->getDeferredDevice(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 667 | SkASSERT(deferredDevice); |
| 668 | if (deferredDevice) { |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 669 | deferredDevice->setNotificationClient(notificationClient); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 670 | } |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 671 | return notificationClient; |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 672 | } |
| 673 | |
junov@chromium.org | 5ee449a | 2013-04-12 20:20:50 +0000 | [diff] [blame] | 674 | SkImage* SkDeferredCanvas::newImageSnapshot() { |
reed@google.com | 9c135db | 2014-03-12 18:28:35 +0000 | [diff] [blame] | 675 | SkDeferredDevice* deferredDevice = this->getDeferredDevice(); |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 676 | SkASSERT(deferredDevice); |
junov@chromium.org | 5ee449a | 2013-04-12 20:20:50 +0000 | [diff] [blame] | 677 | return deferredDevice ? deferredDevice->newImageSnapshot() : NULL; |
junov@chromium.org | 67d7422 | 2013-04-12 13:33:01 +0000 | [diff] [blame] | 678 | } |
| 679 | |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 680 | bool SkDeferredCanvas::isFullFrame(const SkRect* rect, |
junov@chromium.org | c16ca92 | 2012-02-24 22:06:27 +0000 | [diff] [blame] | 681 | const SkPaint* paint) const { |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 682 | SkCanvas* canvas = this->drawingCanvas(); |
yunchao.he | 49005bf | 2014-09-15 22:30:38 -0700 | [diff] [blame] | 683 | SkISize canvasSize = this->getCanvasSize(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 684 | if (rect) { |
| 685 | if (!canvas->getTotalMatrix().rectStaysRect()) { |
| 686 | return false; // conservative |
| 687 | } |
| 688 | |
| 689 | SkRect transformedRect; |
| 690 | canvas->getTotalMatrix().mapRect(&transformedRect, *rect); |
| 691 | |
| 692 | if (paint) { |
| 693 | SkPaint::Style paintStyle = paint->getStyle(); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 694 | if (!(paintStyle == SkPaint::kFill_Style || |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 695 | paintStyle == SkPaint::kStrokeAndFill_Style)) { |
| 696 | return false; |
| 697 | } |
| 698 | if (paint->getMaskFilter() || paint->getLooper() |
| 699 | || paint->getPathEffect() || paint->getImageFilter()) { |
| 700 | return false; // conservative |
| 701 | } |
| 702 | } |
| 703 | |
| 704 | // The following test holds with AA enabled, and is conservative |
| 705 | // by a 0.5 pixel margin with AA disabled |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 706 | if (transformedRect.fLeft > SkIntToScalar(0) || |
| 707 | transformedRect.fTop > SkIntToScalar(0) || |
junov@chromium.org | b1e218e | 2012-02-13 22:27:58 +0000 | [diff] [blame] | 708 | transformedRect.fRight < SkIntToScalar(canvasSize.fWidth) || |
| 709 | transformedRect.fBottom < SkIntToScalar(canvasSize.fHeight)) { |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 710 | return false; |
| 711 | } |
| 712 | } |
| 713 | |
junov@chromium.org | 8f0ca06 | 2012-12-13 16:30:39 +0000 | [diff] [blame] | 714 | return this->getClipStack()->quickContains(SkRect::MakeXYWH(0, 0, |
| 715 | SkIntToScalar(canvasSize.fWidth), SkIntToScalar(canvasSize.fHeight))); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 716 | } |
| 717 | |
Florin Malita | 5f6102d | 2014-06-30 10:13:28 -0400 | [diff] [blame] | 718 | void SkDeferredCanvas::willSave() { |
junov | 3fcc125 | 2014-12-15 11:34:06 -0800 | [diff] [blame] | 719 | fSaveLevel++; |
Florin Malita | 5f6102d | 2014-06-30 10:13:28 -0400 | [diff] [blame] | 720 | this->drawingCanvas()->save(); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 721 | this->recordedDrawCommand(); |
Florin Malita | 5f6102d | 2014-06-30 10:13:28 -0400 | [diff] [blame] | 722 | this->INHERITED::willSave(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 723 | } |
| 724 | |
commit-bot@chromium.org | e54a23f | 2014-03-12 20:21:48 +0000 | [diff] [blame] | 725 | SkCanvas::SaveLayerStrategy SkDeferredCanvas::willSaveLayer(const SkRect* bounds, |
| 726 | const SkPaint* paint, SaveFlags flags) { |
junov | 3fcc125 | 2014-12-15 11:34:06 -0800 | [diff] [blame] | 727 | fSaveLevel++; |
| 728 | if (fFirstSaveLayerIndex == kNoSaveLayerIndex) { |
| 729 | fFirstSaveLayerIndex = fSaveLevel; |
| 730 | this->getDeferredDevice()->setIsDrawingToLayer(true); |
| 731 | } |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 732 | this->drawingCanvas()->saveLayer(bounds, paint, flags); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 733 | this->recordedDrawCommand(); |
commit-bot@chromium.org | e54a23f | 2014-03-12 20:21:48 +0000 | [diff] [blame] | 734 | this->INHERITED::willSaveLayer(bounds, paint, flags); |
| 735 | // No need for a full layer. |
| 736 | return kNoLayer_SaveLayerStrategy; |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 737 | } |
| 738 | |
commit-bot@chromium.org | e54a23f | 2014-03-12 20:21:48 +0000 | [diff] [blame] | 739 | void SkDeferredCanvas::willRestore() { |
junov | 3fcc125 | 2014-12-15 11:34:06 -0800 | [diff] [blame] | 740 | SkASSERT(fFirstSaveLayerIndex == kNoSaveLayerIndex || fFirstSaveLayerIndex <= fSaveLevel); |
| 741 | if (fFirstSaveLayerIndex == fSaveLevel) { |
| 742 | fFirstSaveLayerIndex = kNoSaveLayerIndex; |
| 743 | this->getDeferredDevice()->setIsDrawingToLayer(false); |
| 744 | } |
| 745 | fSaveLevel--; |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 746 | this->drawingCanvas()->restore(); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 747 | this->recordedDrawCommand(); |
commit-bot@chromium.org | e54a23f | 2014-03-12 20:21:48 +0000 | [diff] [blame] | 748 | this->INHERITED::willRestore(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 749 | } |
| 750 | |
commit-bot@chromium.org | 44c48d0 | 2014-03-13 20:03:58 +0000 | [diff] [blame] | 751 | void SkDeferredCanvas::didConcat(const SkMatrix& matrix) { |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 752 | this->drawingCanvas()->concat(matrix); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 753 | this->recordedDrawCommand(); |
commit-bot@chromium.org | 44c48d0 | 2014-03-13 20:03:58 +0000 | [diff] [blame] | 754 | this->INHERITED::didConcat(matrix); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 755 | } |
| 756 | |
commit-bot@chromium.org | 44c48d0 | 2014-03-13 20:03:58 +0000 | [diff] [blame] | 757 | void SkDeferredCanvas::didSetMatrix(const SkMatrix& matrix) { |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 758 | this->drawingCanvas()->setMatrix(matrix); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 759 | this->recordedDrawCommand(); |
commit-bot@chromium.org | 44c48d0 | 2014-03-13 20:03:58 +0000 | [diff] [blame] | 760 | this->INHERITED::didSetMatrix(matrix); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 761 | } |
| 762 | |
robertphillips@google.com | 8f90a89 | 2014-02-28 18:19:39 +0000 | [diff] [blame] | 763 | void SkDeferredCanvas::onClipRect(const SkRect& rect, |
| 764 | SkRegion::Op op, |
| 765 | ClipEdgeStyle edgeStyle) { |
| 766 | this->drawingCanvas()->clipRect(rect, op, kSoft_ClipEdgeStyle == edgeStyle); |
| 767 | this->INHERITED::onClipRect(rect, op, edgeStyle); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 768 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 769 | } |
| 770 | |
robertphillips@google.com | 8f90a89 | 2014-02-28 18:19:39 +0000 | [diff] [blame] | 771 | void SkDeferredCanvas::onClipRRect(const SkRRect& rrect, |
| 772 | SkRegion::Op op, |
| 773 | ClipEdgeStyle edgeStyle) { |
| 774 | this->drawingCanvas()->clipRRect(rrect, op, kSoft_ClipEdgeStyle == edgeStyle); |
| 775 | this->INHERITED::onClipRRect(rrect, op, edgeStyle); |
reed@google.com | 4ed0fb7 | 2012-12-12 20:48:18 +0000 | [diff] [blame] | 776 | this->recordedDrawCommand(); |
reed@google.com | 4ed0fb7 | 2012-12-12 20:48:18 +0000 | [diff] [blame] | 777 | } |
| 778 | |
robertphillips@google.com | 8f90a89 | 2014-02-28 18:19:39 +0000 | [diff] [blame] | 779 | void SkDeferredCanvas::onClipPath(const SkPath& path, |
| 780 | SkRegion::Op op, |
| 781 | ClipEdgeStyle edgeStyle) { |
| 782 | this->drawingCanvas()->clipPath(path, op, kSoft_ClipEdgeStyle == edgeStyle); |
| 783 | this->INHERITED::onClipPath(path, op, edgeStyle); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 784 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 785 | } |
| 786 | |
robertphillips@google.com | 8f90a89 | 2014-02-28 18:19:39 +0000 | [diff] [blame] | 787 | void SkDeferredCanvas::onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) { |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 788 | this->drawingCanvas()->clipRegion(deviceRgn, op); |
robertphillips@google.com | 8f90a89 | 2014-02-28 18:19:39 +0000 | [diff] [blame] | 789 | this->INHERITED::onClipRegion(deviceRgn, op); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 790 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 791 | } |
| 792 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 793 | void SkDeferredCanvas::onDrawPaint(const SkPaint& paint) { |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 794 | if (fDeferredDrawing && this->isFullFrame(NULL, &paint) && |
junov@chromium.org | c16ca92 | 2012-02-24 22:06:27 +0000 | [diff] [blame] | 795 | isPaintOpaque(&paint)) { |
junov@chromium.org | 0a67f96 | 2012-09-19 22:48:34 +0000 | [diff] [blame] | 796 | this->getDeferredDevice()->skipPendingCommands(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 797 | } |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 798 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 799 | this->drawingCanvas()->drawPaint(paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 800 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 801 | } |
| 802 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 803 | void SkDeferredCanvas::onDrawPoints(PointMode mode, size_t count, |
| 804 | const SkPoint pts[], const SkPaint& paint) { |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 805 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 806 | this->drawingCanvas()->drawPoints(mode, count, pts, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 807 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 808 | } |
| 809 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 810 | void SkDeferredCanvas::onDrawOval(const SkRect& rect, const SkPaint& paint) { |
reed@google.com | 4ed0fb7 | 2012-12-12 20:48:18 +0000 | [diff] [blame] | 811 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
| 812 | this->drawingCanvas()->drawOval(rect, paint); |
| 813 | this->recordedDrawCommand(); |
| 814 | } |
| 815 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 816 | void SkDeferredCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) { |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 817 | if (fDeferredDrawing && this->isFullFrame(&rect, &paint) && |
junov@chromium.org | c16ca92 | 2012-02-24 22:06:27 +0000 | [diff] [blame] | 818 | isPaintOpaque(&paint)) { |
junov@chromium.org | 0a67f96 | 2012-09-19 22:48:34 +0000 | [diff] [blame] | 819 | this->getDeferredDevice()->skipPendingCommands(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 820 | } |
skia.committer@gmail.com | 306ab9d | 2012-12-13 02:01:33 +0000 | [diff] [blame] | 821 | |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 822 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 823 | this->drawingCanvas()->drawRect(rect, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 824 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 825 | } |
| 826 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 827 | void SkDeferredCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) { |
reed@google.com | 4ed0fb7 | 2012-12-12 20:48:18 +0000 | [diff] [blame] | 828 | if (rrect.isRect()) { |
| 829 | this->SkDeferredCanvas::drawRect(rrect.getBounds(), paint); |
| 830 | } else if (rrect.isOval()) { |
| 831 | this->SkDeferredCanvas::drawOval(rrect.getBounds(), paint); |
| 832 | } else { |
| 833 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
| 834 | this->drawingCanvas()->drawRRect(rrect, paint); |
| 835 | this->recordedDrawCommand(); |
| 836 | } |
| 837 | } |
| 838 | |
commit-bot@chromium.org | ab58273 | 2014-02-21 12:20:45 +0000 | [diff] [blame] | 839 | void SkDeferredCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner, |
| 840 | const SkPaint& paint) { |
| 841 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
| 842 | this->drawingCanvas()->drawDRRect(outer, inner, paint); |
| 843 | this->recordedDrawCommand(); |
| 844 | } |
| 845 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 846 | void SkDeferredCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) { |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 847 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 848 | this->drawingCanvas()->drawPath(path, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 849 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 850 | } |
| 851 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 852 | void SkDeferredCanvas::onDrawBitmap(const SkBitmap& bitmap, SkScalar left, |
| 853 | SkScalar top, const SkPaint* paint) { |
junov@chromium.org | 8f9ecbd | 2012-02-13 21:53:45 +0000 | [diff] [blame] | 854 | SkRect bitmapRect = SkRect::MakeXYWH(left, top, |
| 855 | SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height())); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 856 | if (fDeferredDrawing && |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 857 | this->isFullFrame(&bitmapRect, paint) && |
junov@chromium.org | 87f982c | 2012-02-23 21:34:34 +0000 | [diff] [blame] | 858 | isPaintOpaque(paint, &bitmap)) { |
junov@chromium.org | 0a67f96 | 2012-09-19 22:48:34 +0000 | [diff] [blame] | 859 | this->getDeferredDevice()->skipPendingCommands(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 860 | } |
| 861 | |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 862 | AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 863 | this->drawingCanvas()->drawBitmap(bitmap, left, top, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 864 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 865 | } |
| 866 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 867 | void SkDeferredCanvas::onDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src, |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame^] | 868 | const SkRect& dst, const SkPaint* paint, |
| 869 | SK_VIRTUAL_CONSTRAINT_TYPE constraint) { |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 870 | if (fDeferredDrawing && |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 871 | this->isFullFrame(&dst, paint) && |
junov@chromium.org | 87f982c | 2012-02-23 21:34:34 +0000 | [diff] [blame] | 872 | isPaintOpaque(paint, &bitmap)) { |
junov@chromium.org | 0a67f96 | 2012-09-19 22:48:34 +0000 | [diff] [blame] | 873 | this->getDeferredDevice()->skipPendingCommands(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 874 | } |
| 875 | |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 876 | AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint); |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame^] | 877 | this->drawingCanvas()->drawBitmapRect(bitmap, src, dst, paint, (SrcRectConstraint)constraint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 878 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 879 | } |
| 880 | |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 881 | |
| 882 | void SkDeferredCanvas::onDrawImage(const SkImage* image, SkScalar x, SkScalar y, |
| 883 | const SkPaint* paint) { |
| 884 | SkRect bounds = SkRect::MakeXYWH(x, y, |
| 885 | SkIntToScalar(image->width()), SkIntToScalar(image->height())); |
| 886 | if (fDeferredDrawing && |
| 887 | this->isFullFrame(&bounds, paint) && |
| 888 | isPaintOpaque(paint, image)) { |
| 889 | this->getDeferredDevice()->skipPendingCommands(); |
| 890 | } |
| 891 | |
| 892 | AutoImmediateDrawIfNeeded autoDraw(*this, image, paint); |
| 893 | this->drawingCanvas()->drawImage(image, x, y, paint); |
| 894 | this->recordedDrawCommand(); |
| 895 | } |
| 896 | void SkDeferredCanvas::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst, |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame^] | 897 | const SkPaint* paint SRC_RECT_CONSTRAINT_PARAM(constraint)) { |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 898 | if (fDeferredDrawing && |
| 899 | this->isFullFrame(&dst, paint) && |
| 900 | isPaintOpaque(paint, image)) { |
| 901 | this->getDeferredDevice()->skipPendingCommands(); |
| 902 | } |
| 903 | |
| 904 | AutoImmediateDrawIfNeeded autoDraw(*this, image, paint); |
reed | a5517e2 | 2015-07-14 10:54:12 -0700 | [diff] [blame^] | 905 | this->drawingCanvas()->drawImageRect(image, src, dst, paint |
| 906 | SRC_RECT_CONSTRAINT_ARG(constraint)); |
reed | a85d4d0 | 2015-05-06 12:56:48 -0700 | [diff] [blame] | 907 | this->recordedDrawCommand(); |
| 908 | } |
| 909 | |
reed | 4c21dc5 | 2015-06-25 12:32:03 -0700 | [diff] [blame] | 910 | void SkDeferredCanvas::onDrawImageNine(const SkImage* image, const SkIRect& center, |
| 911 | const SkRect& dst, const SkPaint* paint) { |
| 912 | if (fDeferredDrawing && |
| 913 | this->isFullFrame(&dst, paint) && |
| 914 | isPaintOpaque(paint, image)) { |
| 915 | this->getDeferredDevice()->skipPendingCommands(); |
| 916 | } |
| 917 | |
| 918 | AutoImmediateDrawIfNeeded autoDraw(*this, image, paint); |
| 919 | this->drawingCanvas()->drawImageNine(image, center, dst, paint); |
| 920 | this->recordedDrawCommand(); |
| 921 | } |
| 922 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 923 | void SkDeferredCanvas::onDrawBitmapNine(const SkBitmap& bitmap, |
| 924 | const SkIRect& center, const SkRect& dst, |
| 925 | const SkPaint* paint) { |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 926 | // TODO: reset recording canvas if paint+bitmap is opaque and clip rect |
| 927 | // covers canvas entirely and dst covers canvas entirely |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 928 | AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 929 | this->drawingCanvas()->drawBitmapNine(bitmap, center, dst, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 930 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 931 | } |
| 932 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 933 | void SkDeferredCanvas::onDrawSprite(const SkBitmap& bitmap, int left, int top, |
| 934 | const SkPaint* paint) { |
junov@chromium.org | 8f9ecbd | 2012-02-13 21:53:45 +0000 | [diff] [blame] | 935 | SkRect bitmapRect = SkRect::MakeXYWH( |
| 936 | SkIntToScalar(left), |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 937 | SkIntToScalar(top), |
junov@chromium.org | 8f9ecbd | 2012-02-13 21:53:45 +0000 | [diff] [blame] | 938 | SkIntToScalar(bitmap.width()), |
| 939 | SkIntToScalar(bitmap.height())); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 940 | if (fDeferredDrawing && |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 941 | this->isFullFrame(&bitmapRect, paint) && |
junov@chromium.org | 87f982c | 2012-02-23 21:34:34 +0000 | [diff] [blame] | 942 | isPaintOpaque(paint, &bitmap)) { |
junov@chromium.org | 0a67f96 | 2012-09-19 22:48:34 +0000 | [diff] [blame] | 943 | this->getDeferredDevice()->skipPendingCommands(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 944 | } |
| 945 | |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 946 | AutoImmediateDrawIfNeeded autoDraw(*this, &bitmap, paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 947 | this->drawingCanvas()->drawSprite(bitmap, left, top, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 948 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 949 | } |
| 950 | |
reed@google.com | e0d9ce8 | 2014-04-23 04:00:17 +0000 | [diff] [blame] | 951 | void SkDeferredCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y, |
| 952 | const SkPaint& paint) { |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 953 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 954 | this->drawingCanvas()->drawText(text, byteLength, x, y, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 955 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 956 | } |
| 957 | |
reed@google.com | e0d9ce8 | 2014-04-23 04:00:17 +0000 | [diff] [blame] | 958 | void SkDeferredCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[], |
| 959 | const SkPaint& paint) { |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 960 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 961 | this->drawingCanvas()->drawPosText(text, byteLength, pos, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 962 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 963 | } |
| 964 | |
reed@google.com | e0d9ce8 | 2014-04-23 04:00:17 +0000 | [diff] [blame] | 965 | void SkDeferredCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[], |
| 966 | SkScalar constY, const SkPaint& paint) { |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 967 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 968 | this->drawingCanvas()->drawPosTextH(text, byteLength, xpos, constY, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 969 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 970 | } |
| 971 | |
reed@google.com | e0d9ce8 | 2014-04-23 04:00:17 +0000 | [diff] [blame] | 972 | void SkDeferredCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path, |
| 973 | const SkMatrix* matrix, const SkPaint& paint) { |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 974 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 975 | this->drawingCanvas()->drawTextOnPath(text, byteLength, path, matrix, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 976 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 977 | } |
| 978 | |
fmalita | b742517 | 2014-08-26 07:56:44 -0700 | [diff] [blame] | 979 | void SkDeferredCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, |
| 980 | const SkPaint& paint) { |
| 981 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
| 982 | this->drawingCanvas()->drawTextBlob(blob, x, y, paint); |
| 983 | this->recordedDrawCommand(); |
| 984 | } |
| 985 | |
reed | d5fa1a4 | 2014-08-09 11:08:05 -0700 | [diff] [blame] | 986 | void SkDeferredCanvas::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix, |
| 987 | const SkPaint* paint) { |
| 988 | this->drawingCanvas()->drawPicture(picture, matrix, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 989 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 990 | } |
| 991 | |
reed | 41af966 | 2015-01-05 07:49:08 -0800 | [diff] [blame] | 992 | void SkDeferredCanvas::onDrawVertices(VertexMode vmode, int vertexCount, |
| 993 | const SkPoint vertices[], |
| 994 | const SkPoint texs[], |
| 995 | const SkColor colors[], SkXfermode* xmode, |
| 996 | const uint16_t indices[], int indexCount, |
| 997 | const SkPaint& paint) { |
junov@chromium.org | 10f7f97 | 2012-07-31 21:01:51 +0000 | [diff] [blame] | 998 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 999 | this->drawingCanvas()->drawVertices(vmode, vertexCount, vertices, texs, colors, xmode, |
| 1000 | indices, indexCount, paint); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 1001 | this->recordedDrawCommand(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 1002 | } |
| 1003 | |
dandov | b3c9d1c | 2014-08-12 08:34:29 -0700 | [diff] [blame] | 1004 | void SkDeferredCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4], |
| 1005 | const SkPoint texCoords[4], SkXfermode* xmode, |
| 1006 | const SkPaint& paint) { |
dandov | 963137b | 2014-08-07 07:49:53 -0700 | [diff] [blame] | 1007 | AutoImmediateDrawIfNeeded autoDraw(*this, &paint); |
dandov | b3c9d1c | 2014-08-12 08:34:29 -0700 | [diff] [blame] | 1008 | this->drawingCanvas()->drawPatch(cubics, colors, texCoords, xmode, paint); |
dandov | 963137b | 2014-08-07 07:49:53 -0700 | [diff] [blame] | 1009 | this->recordedDrawCommand(); |
dandov | ecfff21 | 2014-08-04 10:02:00 -0700 | [diff] [blame] | 1010 | } |
| 1011 | |
reed | 71c3c76 | 2015-06-24 10:29:17 -0700 | [diff] [blame] | 1012 | void SkDeferredCanvas::onDrawAtlas(const SkImage* atlas, const SkRSXform xform[], |
| 1013 | const SkRect tex[], const SkColor colors[], int count, |
| 1014 | SkXfermode::Mode mode, const SkRect* cullRect, |
| 1015 | const SkPaint* paint) { |
| 1016 | AutoImmediateDrawIfNeeded autoDraw(*this, paint); |
| 1017 | this->drawingCanvas()->drawAtlas(atlas, xform, tex, colors, count, mode, cullRect, paint); |
| 1018 | this->recordedDrawCommand(); |
| 1019 | } |
| 1020 | |
junov@chromium.org | c16ca92 | 2012-02-24 22:06:27 +0000 | [diff] [blame] | 1021 | SkDrawFilter* SkDeferredCanvas::setDrawFilter(SkDrawFilter* filter) { |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 1022 | this->drawingCanvas()->setDrawFilter(filter); |
junov@chromium.org | 9ed02b9 | 2012-08-14 13:36:26 +0000 | [diff] [blame] | 1023 | this->INHERITED::setDrawFilter(filter); |
| 1024 | this->recordedDrawCommand(); |
rmistry@google.com | d6176b0 | 2012-08-23 18:14:13 +0000 | [diff] [blame] | 1025 | return filter; |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 1026 | } |
| 1027 | |
| 1028 | SkCanvas* SkDeferredCanvas::canvasForDrawIter() { |
junov@chromium.org | 9060c9b | 2012-08-07 15:14:01 +0000 | [diff] [blame] | 1029 | return this->drawingCanvas(); |
junov@google.com | 4370aed | 2012-01-18 16:21:08 +0000 | [diff] [blame] | 1030 | } |