robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +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 | #ifndef SkMatrixClipStateMgr_DEFINED |
| 8 | #define SkMatrixClipStateMgr_DEFINED |
| 9 | |
| 10 | #include "SkCanvas.h" |
| 11 | #include "SkMatrix.h" |
| 12 | #include "SkRegion.h" |
| 13 | #include "SkRRect.h" |
| 14 | #include "SkTypes.h" |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 15 | #include "SkTDArray.h" |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 16 | |
| 17 | class SkPictureRecord; |
| 18 | class SkWriter32; |
| 19 | |
| 20 | // The SkMatrixClipStateMgr collapses the matrix/clip state of an SkPicture into |
| 21 | // a series of save/restore blocks of consistent matrix clip state, e.g.: |
| 22 | // |
| 23 | // save |
| 24 | // clip(s) |
| 25 | // concat |
| 26 | // ... draw ops ... |
| 27 | // restore |
| 28 | // |
| 29 | // SaveLayers simply add another level, e.g.: |
| 30 | // |
| 31 | // save |
| 32 | // clip(s) |
| 33 | // concat |
| 34 | // ... draw ops ... |
| 35 | // saveLayer |
| 36 | // save |
| 37 | // clip(s) |
| 38 | // concat |
| 39 | // ... draw ops ... |
| 40 | // restore |
| 41 | // restore |
| 42 | // restore |
| 43 | // |
| 44 | // As a side effect of this process all saves and saveLayers will become |
| 45 | // kMatrixClip_SaveFlag style saves/saveLayers. |
| 46 | |
| 47 | // The SkMatrixClipStateMgr works by intercepting all the save*, restore, clip*, |
| 48 | // and matrix calls sent to SkCanvas in order to track the current matrix/clip |
skia.committer@gmail.com | 877c449 | 2014-02-12 03:02:04 +0000 | [diff] [blame] | 49 | // state. All the other canvas calls get funnelled into a generic "call" entry |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 50 | // point that signals that a state block is required. |
| 51 | class SkMatrixClipStateMgr { |
| 52 | public: |
| 53 | static const int32_t kIdentityWideOpenStateID = 0; |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 54 | static const int kIdentityMatID = 0; |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 55 | |
commit-bot@chromium.org | e3beb6b | 2014-04-07 19:34:38 +0000 | [diff] [blame^] | 56 | class MatrixClipState : SkNoncopyable { |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 57 | public: |
| 58 | class MatrixInfo { |
| 59 | public: |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 60 | void reset() { |
| 61 | fMatrixID = kIdentityMatID; |
| 62 | fMatrix.reset(); |
| 63 | } |
| 64 | |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 65 | void preTranslate(SkScalar dx, SkScalar dy) { |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 66 | fMatrixID = -1; |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 67 | fMatrix.preTranslate(dx, dy); |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 68 | } |
| 69 | |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 70 | void preScale(SkScalar sx, SkScalar sy) { |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 71 | fMatrixID = -1; |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 72 | fMatrix.preScale(sx, sy); |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 73 | } |
| 74 | |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 75 | void preRotate(SkScalar degrees) { |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 76 | fMatrixID = -1; |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 77 | fMatrix.preRotate(degrees); |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 78 | } |
| 79 | |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 80 | void preSkew(SkScalar sx, SkScalar sy) { |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 81 | fMatrixID = -1; |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 82 | fMatrix.preSkew(sx, sy); |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 83 | } |
| 84 | |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 85 | void preConcat(const SkMatrix& matrix) { |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 86 | fMatrixID = -1; |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 87 | fMatrix.preConcat(matrix); |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | void setMatrix(const SkMatrix& matrix) { |
| 91 | fMatrixID = -1; |
| 92 | fMatrix = matrix; |
| 93 | } |
| 94 | |
| 95 | int getID(SkMatrixClipStateMgr* mgr) { |
| 96 | if (fMatrixID >= 0) { |
| 97 | return fMatrixID; |
| 98 | } |
| 99 | |
| 100 | fMatrixID = mgr->addMatToDict(fMatrix); |
| 101 | return fMatrixID; |
| 102 | } |
| 103 | |
| 104 | private: |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 105 | SkMatrix fMatrix; |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 106 | int fMatrixID; |
commit-bot@chromium.org | 6c5f1fd | 2014-02-24 17:24:15 +0000 | [diff] [blame] | 107 | |
| 108 | typedef SkNoncopyable INHERITED; |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 109 | }; |
| 110 | |
commit-bot@chromium.org | e3beb6b | 2014-04-07 19:34:38 +0000 | [diff] [blame^] | 111 | class ClipInfo : SkNoncopyable { |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 112 | public: |
| 113 | ClipInfo() {} |
| 114 | |
skia.committer@gmail.com | 877c449 | 2014-02-12 03:02:04 +0000 | [diff] [blame] | 115 | bool clipRect(const SkRect& rect, |
| 116 | SkRegion::Op op, |
| 117 | bool doAA, |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 118 | int matrixID) { |
commit-bot@chromium.org | 9a67a7e | 2014-02-12 23:22:15 +0000 | [diff] [blame] | 119 | ClipOp* newClip = fClips.append(); |
| 120 | newClip->fClipType = kRect_ClipType; |
| 121 | newClip->fGeom.fRRect.setRect(rect); // storing the clipRect in the RRect |
| 122 | newClip->fOp = op; |
| 123 | newClip->fDoAA = doAA; |
| 124 | newClip->fMatrixID = matrixID; |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 125 | return false; |
| 126 | } |
| 127 | |
skia.committer@gmail.com | 877c449 | 2014-02-12 03:02:04 +0000 | [diff] [blame] | 128 | bool clipRRect(const SkRRect& rrect, |
| 129 | SkRegion::Op op, |
| 130 | bool doAA, |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 131 | int matrixID) { |
commit-bot@chromium.org | 9a67a7e | 2014-02-12 23:22:15 +0000 | [diff] [blame] | 132 | ClipOp* newClip = fClips.append(); |
| 133 | newClip->fClipType = kRRect_ClipType; |
| 134 | newClip->fGeom.fRRect = rrect; |
| 135 | newClip->fOp = op; |
| 136 | newClip->fDoAA = doAA; |
| 137 | newClip->fMatrixID = matrixID; |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 138 | return false; |
| 139 | } |
| 140 | |
skia.committer@gmail.com | 877c449 | 2014-02-12 03:02:04 +0000 | [diff] [blame] | 141 | bool clipPath(SkPictureRecord* picRecord, |
| 142 | const SkPath& path, |
| 143 | SkRegion::Op op, |
| 144 | bool doAA, |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 145 | int matrixID); |
skia.committer@gmail.com | 877c449 | 2014-02-12 03:02:04 +0000 | [diff] [blame] | 146 | bool clipRegion(SkPictureRecord* picRecord, |
commit-bot@chromium.org | 9a67a7e | 2014-02-12 23:22:15 +0000 | [diff] [blame] | 147 | int regionID, |
skia.committer@gmail.com | 877c449 | 2014-02-12 03:02:04 +0000 | [diff] [blame] | 148 | SkRegion::Op op, |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 149 | int matrixID); |
commit-bot@chromium.org | 92da60c | 2014-02-19 15:11:23 +0000 | [diff] [blame] | 150 | void writeClip(int* curMatID, SkMatrixClipStateMgr* mgr); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 151 | |
commit-bot@chromium.org | 92da60c | 2014-02-19 15:11:23 +0000 | [diff] [blame] | 152 | SkDEBUGCODE(int numClips() const { return fClips.count(); }) |
| 153 | |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 154 | private: |
| 155 | enum ClipType { |
| 156 | kRect_ClipType, |
| 157 | kRRect_ClipType, |
| 158 | kPath_ClipType, |
| 159 | kRegion_ClipType |
| 160 | }; |
| 161 | |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 162 | class ClipOp { |
| 163 | public: |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 164 | ClipType fClipType; |
| 165 | |
| 166 | union { |
commit-bot@chromium.org | 6c5f1fd | 2014-02-24 17:24:15 +0000 | [diff] [blame] | 167 | SkRRect fRRect; // also stores clip rect |
commit-bot@chromium.org | 9a67a7e | 2014-02-12 23:22:15 +0000 | [diff] [blame] | 168 | int fPathID; |
| 169 | int fRegionID; |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 170 | } fGeom; |
| 171 | |
| 172 | bool fDoAA; |
| 173 | SkRegion::Op fOp; |
| 174 | |
| 175 | // The CTM in effect when this clip call was issued |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 176 | int fMatrixID; |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 177 | }; |
| 178 | |
commit-bot@chromium.org | 9a67a7e | 2014-02-12 23:22:15 +0000 | [diff] [blame] | 179 | SkTDArray<ClipOp> fClips; |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 180 | |
| 181 | typedef SkNoncopyable INHERITED; |
| 182 | }; |
| 183 | |
skia.committer@gmail.com | 877c449 | 2014-02-12 03:02:04 +0000 | [diff] [blame] | 184 | MatrixClipState(MatrixClipState* prev, int flags) |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 185 | : fPrev(prev) |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 186 | { |
robertphillips@google.com | fc4ded9 | 2014-02-21 17:46:37 +0000 | [diff] [blame] | 187 | fHasOpen = false; |
| 188 | |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 189 | if (NULL == prev) { |
| 190 | fLayerID = 0; |
| 191 | |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 192 | fMatrixInfoStorage.reset(); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 193 | fMatrixInfo = &fMatrixInfoStorage; |
| 194 | fClipInfo = &fClipInfoStorage; // ctor handles init of fClipInfoStorage |
| 195 | |
| 196 | // The identity/wide-open-clip state is current by default |
| 197 | fMCStateID = kIdentityWideOpenStateID; |
robertphillips@google.com | fc4ded9 | 2014-02-21 17:46:37 +0000 | [diff] [blame] | 198 | #ifdef SK_DEBUG |
| 199 | fExpectedDepth = 1; |
| 200 | #endif |
skia.committer@gmail.com | 877c449 | 2014-02-12 03:02:04 +0000 | [diff] [blame] | 201 | } |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 202 | else { |
| 203 | fLayerID = prev->fLayerID; |
| 204 | |
| 205 | if (flags & SkCanvas::kMatrix_SaveFlag) { |
| 206 | fMatrixInfoStorage = *prev->fMatrixInfo; |
| 207 | fMatrixInfo = &fMatrixInfoStorage; |
| 208 | } else { |
| 209 | fMatrixInfo = prev->fMatrixInfo; |
| 210 | } |
| 211 | |
| 212 | if (flags & SkCanvas::kClip_SaveFlag) { |
| 213 | // We don't copy the ClipOps of the previous clip states |
| 214 | fClipInfo = &fClipInfoStorage; |
| 215 | } else { |
| 216 | fClipInfo = prev->fClipInfo; |
| 217 | } |
| 218 | |
| 219 | // Initially a new save/saveLayer represents the same MC state |
| 220 | // as its predecessor. |
| 221 | fMCStateID = prev->fMCStateID; |
robertphillips@google.com | fc4ded9 | 2014-02-21 17:46:37 +0000 | [diff] [blame] | 222 | #ifdef SK_DEBUG |
| 223 | fExpectedDepth = prev->fExpectedDepth; |
| 224 | #endif |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 225 | } |
| 226 | |
| 227 | fIsSaveLayer = false; |
| 228 | } |
| 229 | |
| 230 | MatrixInfo* fMatrixInfo; |
| 231 | MatrixInfo fMatrixInfoStorage; |
| 232 | |
| 233 | ClipInfo* fClipInfo; |
| 234 | ClipInfo fClipInfoStorage; |
| 235 | |
| 236 | // Tracks the current depth of saveLayers to support the isDrawingToLayer call |
| 237 | int fLayerID; |
| 238 | // Does this MC state represent a saveLayer call? |
| 239 | bool fIsSaveLayer; |
| 240 | |
commit-bot@chromium.org | 6c5f1fd | 2014-02-24 17:24:15 +0000 | [diff] [blame] | 241 | // The next field is only valid when fIsSaveLayer is set. |
commit-bot@chromium.org | 92da60c | 2014-02-19 15:11:23 +0000 | [diff] [blame] | 242 | SkTDArray<int>* fSavedSkipOffsets; |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 243 | |
robertphillips@google.com | fc4ded9 | 2014-02-21 17:46:37 +0000 | [diff] [blame] | 244 | // Does the MC state have an open block in the skp? |
| 245 | bool fHasOpen; |
| 246 | |
skia.committer@gmail.com | 7911ade | 2014-02-22 03:02:18 +0000 | [diff] [blame] | 247 | MatrixClipState* fPrev; |
robertphillips@google.com | fc4ded9 | 2014-02-21 17:46:37 +0000 | [diff] [blame] | 248 | |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 249 | #ifdef SK_DEBUG |
robertphillips@google.com | fc4ded9 | 2014-02-21 17:46:37 +0000 | [diff] [blame] | 250 | int fExpectedDepth; // debugging aid |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 251 | #endif |
| 252 | |
| 253 | int32_t fMCStateID; |
| 254 | }; |
| 255 | |
| 256 | enum CallType { |
| 257 | kMatrix_CallType, |
| 258 | kClip_CallType, |
| 259 | kOther_CallType |
| 260 | }; |
| 261 | |
| 262 | SkMatrixClipStateMgr(); |
commit-bot@chromium.org | 9a67a7e | 2014-02-12 23:22:15 +0000 | [diff] [blame] | 263 | ~SkMatrixClipStateMgr(); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 264 | |
| 265 | void init(SkPictureRecord* picRecord) { |
| 266 | // Note: we're not taking a ref here. It is expected that the SkMatrixClipStateMgr |
| 267 | // is owned by the SkPictureRecord object |
skia.committer@gmail.com | 877c449 | 2014-02-12 03:02:04 +0000 | [diff] [blame] | 268 | fPicRecord = picRecord; |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 269 | } |
| 270 | |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 271 | SkPictureRecord* getPicRecord() { return fPicRecord; } |
| 272 | |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 273 | // TODO: need to override canvas' getSaveCount. Right now we pass the |
| 274 | // save* and restore calls on to the base SkCanvas in SkPictureRecord but |
| 275 | // this duplicates effort. |
| 276 | int getSaveCount() const { return fMatrixClipStack.count(); } |
| 277 | |
| 278 | int save(SkCanvas::SaveFlags flags); |
| 279 | |
| 280 | int saveLayer(const SkRect* bounds, const SkPaint* paint, SkCanvas::SaveFlags flags); |
| 281 | |
| 282 | bool isDrawingToLayer() const { |
| 283 | return fCurMCState->fLayerID > 0; |
| 284 | } |
| 285 | |
| 286 | void restore(); |
| 287 | |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 288 | void translate(SkScalar dx, SkScalar dy) { |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 289 | this->call(kMatrix_CallType); |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 290 | fCurMCState->fMatrixInfo->preTranslate(dx, dy); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 291 | } |
| 292 | |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 293 | void scale(SkScalar sx, SkScalar sy) { |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 294 | this->call(kMatrix_CallType); |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 295 | fCurMCState->fMatrixInfo->preScale(sx, sy); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 296 | } |
| 297 | |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 298 | void rotate(SkScalar degrees) { |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 299 | this->call(kMatrix_CallType); |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 300 | fCurMCState->fMatrixInfo->preRotate(degrees); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 301 | } |
| 302 | |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 303 | void skew(SkScalar sx, SkScalar sy) { |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 304 | this->call(kMatrix_CallType); |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 305 | fCurMCState->fMatrixInfo->preSkew(sx, sy); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 306 | } |
| 307 | |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 308 | void concat(const SkMatrix& matrix) { |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 309 | this->call(kMatrix_CallType); |
commit-bot@chromium.org | 9236238 | 2014-03-18 12:51:48 +0000 | [diff] [blame] | 310 | fCurMCState->fMatrixInfo->preConcat(matrix); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 311 | } |
| 312 | |
| 313 | void setMatrix(const SkMatrix& matrix) { |
| 314 | this->call(kMatrix_CallType); |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 315 | fCurMCState->fMatrixInfo->setMatrix(matrix); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 316 | } |
| 317 | |
| 318 | bool clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) { |
| 319 | this->call(SkMatrixClipStateMgr::kClip_CallType); |
| 320 | return fCurMCState->fClipInfo->clipRect(rect, op, doAA, |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 321 | fCurMCState->fMatrixInfo->getID(this)); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 322 | } |
| 323 | |
| 324 | bool clipRRect(const SkRRect& rrect, SkRegion::Op op, bool doAA) { |
| 325 | this->call(SkMatrixClipStateMgr::kClip_CallType); |
| 326 | return fCurMCState->fClipInfo->clipRRect(rrect, op, doAA, |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 327 | fCurMCState->fMatrixInfo->getID(this)); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 328 | } |
| 329 | |
| 330 | bool clipPath(const SkPath& path, SkRegion::Op op, bool doAA) { |
| 331 | this->call(SkMatrixClipStateMgr::kClip_CallType); |
| 332 | return fCurMCState->fClipInfo->clipPath(fPicRecord, path, op, doAA, |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 333 | fCurMCState->fMatrixInfo->getID(this)); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 334 | } |
| 335 | |
| 336 | bool clipRegion(const SkRegion& region, SkRegion::Op op) { |
| 337 | this->call(SkMatrixClipStateMgr::kClip_CallType); |
commit-bot@chromium.org | 9a67a7e | 2014-02-12 23:22:15 +0000 | [diff] [blame] | 338 | int regionID = this->addRegionToDict(region); |
| 339 | return fCurMCState->fClipInfo->clipRegion(fPicRecord, regionID, op, |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 340 | fCurMCState->fMatrixInfo->getID(this)); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 341 | } |
| 342 | |
| 343 | bool call(CallType callType); |
| 344 | |
commit-bot@chromium.org | 92da60c | 2014-02-19 15:11:23 +0000 | [diff] [blame] | 345 | void fillInSkips(SkWriter32* writer, int32_t restoreOffset); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 346 | |
| 347 | void finish(); |
| 348 | |
| 349 | protected: |
| 350 | SkPictureRecord* fPicRecord; |
| 351 | |
| 352 | uint32_t fMatrixClipStackStorage[43]; // sized to fit 2 clip states |
| 353 | SkDeque fMatrixClipStack; |
| 354 | MatrixClipState* fCurMCState; |
| 355 | |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 356 | // This dictionary doesn't actually de-duplicate the matrices (except for the |
| 357 | // identity matrix). It merely stores the matrices and allows them to be looked |
skia.committer@gmail.com | 22ef2c3 | 2014-02-13 03:01:57 +0000 | [diff] [blame] | 358 | // up by ID later. The de-duplication mainly falls upon the matrix/clip stack |
| 359 | // which stores the ID so a revisited clip/matrix (via popping the stack) will |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 360 | // use the same ID. |
| 361 | SkTDArray<SkMatrix> fMatrixDict; |
| 362 | |
commit-bot@chromium.org | 9a67a7e | 2014-02-12 23:22:15 +0000 | [diff] [blame] | 363 | SkTDArray<SkRegion*> fRegionDict; |
| 364 | |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 365 | // The MCStateID of the state currently in effect in the byte stream. 0 if none. |
| 366 | int32_t fCurOpenStateID; |
skia.committer@gmail.com | c05d285 | 2014-02-20 03:01:56 +0000 | [diff] [blame] | 367 | // The skip offsets for the current open state. These are the locations in the |
commit-bot@chromium.org | 92da60c | 2014-02-19 15:11:23 +0000 | [diff] [blame] | 368 | // skp that must be filled in when the current open state is closed. These are |
| 369 | // here rather then distributed across the MatrixClipState's because saveLayers |
| 370 | // can cause MC states to be nested. |
| 371 | SkTDArray<int32_t> *fSkipOffsets; |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 372 | |
| 373 | SkDEBUGCODE(void validate();) |
| 374 | |
commit-bot@chromium.org | 92da60c | 2014-02-19 15:11:23 +0000 | [diff] [blame] | 375 | int MCStackPush(SkCanvas::SaveFlags flags); |
| 376 | |
| 377 | void addClipOffset(int offset) { |
| 378 | SkASSERT(NULL != fSkipOffsets); |
| 379 | SkASSERT(kIdentityWideOpenStateID != fCurOpenStateID); |
robertphillips@google.com | fc4ded9 | 2014-02-21 17:46:37 +0000 | [diff] [blame] | 380 | SkASSERT(fCurMCState->fHasOpen); |
| 381 | SkASSERT(!fCurMCState->fIsSaveLayer); |
commit-bot@chromium.org | 92da60c | 2014-02-19 15:11:23 +0000 | [diff] [blame] | 382 | |
| 383 | *fSkipOffsets->append() = offset; |
| 384 | } |
| 385 | |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 386 | void writeDeltaMat(int currentMatID, int desiredMatID); |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 387 | static int32_t NewMCStateID(); |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 388 | |
commit-bot@chromium.org | 9a67a7e | 2014-02-12 23:22:15 +0000 | [diff] [blame] | 389 | int addRegionToDict(const SkRegion& region); |
| 390 | const SkRegion* lookupRegion(int index) { |
| 391 | SkASSERT(index >= 0 && index < fRegionDict.count()); |
skia.committer@gmail.com | 22ef2c3 | 2014-02-13 03:01:57 +0000 | [diff] [blame] | 392 | return fRegionDict[index]; |
commit-bot@chromium.org | 9a67a7e | 2014-02-12 23:22:15 +0000 | [diff] [blame] | 393 | } |
| 394 | |
commit-bot@chromium.org | c5dada8 | 2014-02-12 15:48:04 +0000 | [diff] [blame] | 395 | // TODO: add stats to check if the dictionary really does |
| 396 | // reduce the size of the SkPicture. |
| 397 | int addMatToDict(const SkMatrix& mat); |
| 398 | const SkMatrix& lookupMat(int index) { |
| 399 | SkASSERT(index >= 0 && index < fMatrixDict.count()); |
| 400 | return fMatrixDict[index]; |
| 401 | } |
robertphillips@google.com | fc4ded9 | 2014-02-21 17:46:37 +0000 | [diff] [blame] | 402 | |
commit-bot@chromium.org | 6c5f1fd | 2014-02-24 17:24:15 +0000 | [diff] [blame] | 403 | bool isNestingMCState(int stateID); |
robertphillips@google.com | fc4ded9 | 2014-02-21 17:46:37 +0000 | [diff] [blame] | 404 | |
| 405 | #ifdef SK_DEBUG |
| 406 | int fActualDepth; |
| 407 | #endif |
commit-bot@chromium.org | 6c5f1fd | 2014-02-24 17:24:15 +0000 | [diff] [blame] | 408 | |
| 409 | // save layers are nested within a specific MC state. This stack tracks |
| 410 | // the nesting MC state's ID as save layers are pushed and popped. |
| 411 | SkTDArray<int> fStateIDStack; |
robertphillips@google.com | 105a4a5 | 2014-02-11 15:10:40 +0000 | [diff] [blame] | 412 | }; |
| 413 | |
robertphillips@google.com | 3cd6fdf | 2014-02-11 15:40:54 +0000 | [diff] [blame] | 414 | #endif |