1 2 /* 3 * Copyright 2012 Google Inc. 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 "SkPictureStateTree.h" 10 #include "SkCanvas.h" 11 12 SkPictureStateTree::SkPictureStateTree() 13 : fAlloc(2048) 14 , fLastRestoredNode(NULL) 15 , fStateStack(sizeof(Draw), 16) { 16 fRootMatrix.reset(); 17 fRoot.fParent = NULL; 18 fRoot.fMatrix = &fRootMatrix; 19 fRoot.fFlags = Node::kSave_Flag; 20 fRoot.fOffset = 0; 21 fRoot.fLevel = 0; 22 fCurrentState.fNode = &fRoot; 23 fCurrentState.fMatrix = &fRootMatrix; 24 *static_cast<Draw*>(fStateStack.push_back()) = fCurrentState; 25 } 26 27 SkPictureStateTree::~SkPictureStateTree() { 28 } 29 30 SkPictureStateTree::Draw* SkPictureStateTree::appendDraw(size_t offset) { 31 Draw* draw = static_cast<Draw*>(fAlloc.allocThrow(sizeof(Draw))); 32 *draw = fCurrentState; 33 draw->fOffset = SkToU32(offset); 34 return draw; 35 } 36 37 void SkPictureStateTree::appendSave() { 38 *static_cast<Draw*>(fStateStack.push_back()) = fCurrentState; 39 fCurrentState.fNode->fFlags |= Node::kSave_Flag; 40 } 41 42 void SkPictureStateTree::appendSaveLayer(size_t offset) { 43 *static_cast<Draw*>(fStateStack.push_back()) = fCurrentState; 44 this->appendNode(offset); 45 fCurrentState.fNode->fFlags |= Node::kSaveLayer_Flag; 46 } 47 48 void SkPictureStateTree::saveCollapsed() { 49 SkASSERT(NULL != fLastRestoredNode); 50 SkASSERT(SkToBool(fLastRestoredNode->fFlags & \ 51 (Node::kSaveLayer_Flag | Node::kSave_Flag))); 52 SkASSERT(fLastRestoredNode->fParent == fCurrentState.fNode); 53 // The structure of the tree is not modified here. We just turn off 54 // the save or saveLayer flag to prevent the iterator from making state 55 // changing calls on the playback canvas when traversing a save or 56 // saveLayerNode node. 57 fLastRestoredNode->fFlags = 0; 58 } 59 60 void SkPictureStateTree::appendRestore() { 61 fLastRestoredNode = fCurrentState.fNode; 62 fCurrentState = *static_cast<Draw*>(fStateStack.back()); 63 fStateStack.pop_back(); 64 } 65 66 void SkPictureStateTree::appendTransform(const SkMatrix& trans) { 67 SkMatrix* m = static_cast<SkMatrix*>(fAlloc.allocThrow(sizeof(SkMatrix))); 68 *m = trans; 69 fCurrentState.fMatrix = m; 70 } 71 72 void SkPictureStateTree::appendClip(size_t offset) { 73 this->appendNode(offset); 74 } 75 76 SkPictureStateTree::Iterator SkPictureStateTree::getIterator(const SkTDArray<void*>& draws, 77 SkCanvas* canvas) { 78 return Iterator(draws, canvas, &fRoot); 79 } 80 81 void SkPictureStateTree::appendNode(size_t offset) { 82 Node* n = static_cast<Node*>(fAlloc.allocThrow(sizeof(Node))); 83 n->fOffset = SkToU32(offset); 84 n->fFlags = 0; 85 n->fParent = fCurrentState.fNode; 86 n->fLevel = fCurrentState.fNode->fLevel + 1; 87 n->fMatrix = fCurrentState.fMatrix; 88 fCurrentState.fNode = n; 89 } 90 91 SkPictureStateTree::Iterator::Iterator(const SkTDArray<void*>& draws, SkCanvas* canvas, Node* root) 92 : fDraws(&draws) 93 , fCanvas(canvas) 94 , fCurrentNode(root) 95 , fPlaybackMatrix(canvas->getTotalMatrix()) 96 , fCurrentMatrix(NULL) 97 , fPlaybackIndex(0) 98 , fSave(false) 99 , fValid(true) { 100 } 101 102 void SkPictureStateTree::Iterator::setCurrentMatrix(const SkMatrix* matrix) { 103 SkASSERT(NULL != matrix); 104 105 if (matrix == fCurrentMatrix) { 106 return; 107 } 108 109 // The matrix is in recording space, but we also inherit 110 // a playback matrix from out target canvas. 111 SkMatrix m = *matrix; 112 m.postConcat(fPlaybackMatrix); 113 fCanvas->setMatrix(m); 114 fCurrentMatrix = matrix; 115 } 116 117 uint32_t SkPictureStateTree::Iterator::finish() { 118 if (fCurrentNode->fFlags & Node::kSaveLayer_Flag) { 119 fCanvas->restore(); 120 } 121 122 for (fCurrentNode = fCurrentNode->fParent; fCurrentNode; 123 fCurrentNode = fCurrentNode->fParent) { 124 // Note: we call restore() twice when both flags are set. 125 if (fCurrentNode->fFlags & Node::kSave_Flag) { 126 fCanvas->restore(); 127 } 128 if (fCurrentNode->fFlags & Node::kSaveLayer_Flag) { 129 fCanvas->restore(); 130 } 131 } 132 133 fCanvas->setMatrix(fPlaybackMatrix); 134 fCurrentMatrix = NULL; 135 return kDrawComplete; 136 } 137 138 uint32_t SkPictureStateTree::Iterator::nextDraw() { 139 SkASSERT(this->isValid()); 140 if (fPlaybackIndex >= fDraws->count()) { 141 return this->finish(); 142 } 143 144 Draw* draw = static_cast<Draw*>((*fDraws)[fPlaybackIndex]); 145 Node* targetNode = draw->fNode; 146 147 if (fSave) { 148 fCanvas->save(); 149 fSave = false; 150 } 151 152 if (fCurrentNode != targetNode) { 153 // If we're not at the target and we don't have a list of nodes to get there, we need to 154 // figure out the path from our current node, to the target 155 if (fNodes.count() == 0) { 156 // Trace back up to a common ancestor, restoring to get our current state to match that 157 // of the ancestor, and saving a list of nodes whose state we need to apply to get to 158 // the target (we can restore up to the ancestor immediately, but we'll need to return 159 // an offset for each node on the way down to the target, to apply the desired clips and 160 // saveLayers, so it may take several draw() calls before the next draw actually occurs) 161 Node* tmp = fCurrentNode; 162 Node* ancestor = targetNode; 163 while (tmp != ancestor) { 164 uint16_t currentLevel = tmp->fLevel; 165 uint16_t targetLevel = ancestor->fLevel; 166 if (currentLevel >= targetLevel) { 167 if (tmp != fCurrentNode && tmp->fFlags & Node::kSave_Flag) { 168 fCanvas->restore(); 169 // restore() may change the matrix, so we need to reapply. 170 fCurrentMatrix = NULL; 171 } 172 if (tmp->fFlags & Node::kSaveLayer_Flag) { 173 fCanvas->restore(); 174 // restore() may change the matrix, so we need to reapply. 175 fCurrentMatrix = NULL; 176 } 177 tmp = tmp->fParent; 178 } 179 if (currentLevel <= targetLevel) { 180 fNodes.push(ancestor); 181 ancestor = ancestor->fParent; 182 } 183 } 184 185 if (ancestor->fFlags & Node::kSave_Flag) { 186 if (fCurrentNode != ancestor) { 187 fCanvas->restore(); 188 // restore() may change the matrix, so we need to reapply. 189 fCurrentMatrix = NULL; 190 } 191 if (targetNode != ancestor) { 192 fCanvas->save(); 193 } 194 } 195 fCurrentNode = ancestor; 196 } 197 198 // If we're not at the target node yet, we'll need to return an offset to make the caller 199 // apply the next clip or saveLayer. 200 if (fCurrentNode != targetNode) { 201 uint32_t offset = fNodes.top()->fOffset; 202 fCurrentNode = fNodes.top(); 203 fSave = fCurrentNode != targetNode && fCurrentNode->fFlags & Node::kSave_Flag; 204 fNodes.pop(); 205 this->setCurrentMatrix(fCurrentNode->fMatrix); 206 return offset; 207 } 208 } 209 210 // If we got this far, the clip/saveLayer state is all set, so we can proceed to set the matrix 211 // for the draw, and return its offset. 212 this->setCurrentMatrix(draw->fMatrix); 213 214 ++fPlaybackIndex; 215 return draw->fOffset; 216 } 217