FrameBuilder.cpp revision 9cd1bbe5c9e14472e631d8cc10005613925f34af
1b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper/* 2b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper * Copyright (C) 2016 The Android Open Source Project 3de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard * 4b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper * Licensed under the Apache License, Version 2.0 (the "License"); 5b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper * you may not use this file except in compliance with the License. 6de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard * You may obtain a copy of the License at 7de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard * 8b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper * http://www.apache.org/licenses/LICENSE-2.0 9de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard * 10de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard * Unless required by applicable law or agreed to in writing, software 11de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard * distributed under the License is distributed on an "AS IS" BASIS, 12de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard * See the License for the specific language governing permissions and 14de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard * limitations under the License. 15de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard */ 16de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard 17de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard#include "FrameBuilder.h" 18de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard 19de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard#include "LayerUpdateQueue.h" 20de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard#include "RenderNode.h" 21de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard#include "VectorDrawable.h" 22361df7da6dfecd817b27e62b91752ac316d7cdd4Ulrich Drepper#include "renderstate/OffscreenBufferPool.h" 23361df7da6dfecd817b27e62b91752ac316d7cdd4Ulrich Drepper#include "hwui/Canvas.h" 24361df7da6dfecd817b27e62b91752ac316d7cdd4Ulrich Drepper#include "utils/FatVector.h" 25361df7da6dfecd817b27e62b91752ac316d7cdd4Ulrich Drepper#include "utils/PaintUtils.h" 26de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard#include "utils/TraceUtils.h" 27de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard 28de2ed97f33139af5c7a0811e4ec66fc896a13cf2Mark Wielaard#include <SkPathOps.h> 29b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper#include <utils/TypeHelpers.h> 30b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper 31b08d5a8fb42f4586d756068065186b5af7e48daUlrich Dreppernamespace android { 32b08d5a8fb42f4586d756068065186b5af7e48daUlrich Dreppernamespace uirenderer { 33b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper 34b08d5a8fb42f4586d756068065186b5af7e48daUlrich DrepperFrameBuilder::FrameBuilder(const SkRect& clip, 35b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper uint32_t viewportWidth, uint32_t viewportHeight, 36b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper const LightGeometry& lightGeometry, Caches& caches) 37b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper : mStdAllocator(mAllocator) 38b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper , mLayerBuilders(mStdAllocator) 39b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper , mLayerStack(mStdAllocator) 40b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper , mCanvasState(*this) 41b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper , mCaches(caches) 421ccdfb683ad6c7e59793136c3a657ddf131cafd1Mark Wielaard , mLightRadius(lightGeometry.radius) 43b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper , mDrawFbo0(true) { 44b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper 45b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper // Prepare to defer Fbo0 46b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper auto fbo0 = mAllocator.create<LayerBuilder>(viewportWidth, viewportHeight, Rect(clip)); 47b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper mLayerBuilders.push_back(fbo0); 48b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper mLayerStack.push_back(0); 49b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper mCanvasState.initializeSaveStack(viewportWidth, viewportHeight, 50b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper clip.fLeft, clip.fTop, clip.fRight, clip.fBottom, 51b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper lightGeometry.center); 52b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper} 53b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper 54b08d5a8fb42f4586d756068065186b5af7e48daUlrich DrepperFrameBuilder::FrameBuilder(const LayerUpdateQueue& layers, 55b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper const LightGeometry& lightGeometry, Caches& caches) 56b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper : mStdAllocator(mAllocator) 57b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper , mLayerBuilders(mStdAllocator) 58b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper , mLayerStack(mStdAllocator) 59b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper , mCanvasState(*this) 60b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper , mCaches(caches) 61b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper , mLightRadius(lightGeometry.radius) 62b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper , mDrawFbo0(false) { 63b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper // TODO: remove, with each layer on its own save stack 64b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper 65b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper // Prepare to defer Fbo0 (which will be empty) 66b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper auto fbo0 = mAllocator.create<LayerBuilder>(1, 1, Rect(1, 1)); 67b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper mLayerBuilders.push_back(fbo0); 68b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper mLayerStack.push_back(0); 69b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper mCanvasState.initializeSaveStack(1, 1, 70b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper 0, 0, 1, 1, 71b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper lightGeometry.center); 72b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper 73b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper deferLayers(layers); 74b08d5a8fb42f4586d756068065186b5af7e48daUlrich Drepper} 75 76void FrameBuilder::deferLayers(const LayerUpdateQueue& layers) { 77 // Render all layers to be updated, in order. Defer in reverse order, so that they'll be 78 // updated in the order they're passed in (mLayerBuilders are issued to Renderer in reverse) 79 for (int i = layers.entries().size() - 1; i >= 0; i--) { 80 RenderNode* layerNode = layers.entries()[i].renderNode; 81 // only schedule repaint if node still on layer - possible it may have been 82 // removed during a dropped frame, but layers may still remain scheduled so 83 // as not to lose info on what portion is damaged 84 if (CC_LIKELY(layerNode->getLayer() != nullptr)) { 85 const Rect& layerDamage = layers.entries()[i].damage; 86 layerNode->computeOrdering(); 87 88 // map current light center into RenderNode's coordinate space 89 Vector3 lightCenter = mCanvasState.currentSnapshot()->getRelativeLightCenter(); 90 layerNode->getLayer()->inverseTransformInWindow.mapPoint3d(lightCenter); 91 92 saveForLayer(layerNode->getWidth(), layerNode->getHeight(), 0, 0, 93 layerDamage, lightCenter, nullptr, layerNode); 94 95 if (layerNode->getDisplayList()) { 96 deferNodeOps(*layerNode); 97 } 98 restoreForLayer(); 99 } 100 } 101} 102 103void FrameBuilder::deferRenderNode(RenderNode& renderNode) { 104 renderNode.computeOrdering(); 105 106 mCanvasState.save(SaveFlags::MatrixClip); 107 deferNodePropsAndOps(renderNode); 108 mCanvasState.restore(); 109} 110 111void FrameBuilder::deferRenderNode(float tx, float ty, Rect clipRect, RenderNode& renderNode) { 112 renderNode.computeOrdering(); 113 114 mCanvasState.save(SaveFlags::MatrixClip); 115 mCanvasState.translate(tx, ty); 116 mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom, 117 SkRegion::kIntersect_Op); 118 deferNodePropsAndOps(renderNode); 119 mCanvasState.restore(); 120} 121 122static Rect nodeBounds(RenderNode& node) { 123 auto& props = node.properties(); 124 return Rect(props.getLeft(), props.getTop(), 125 props.getRight(), props.getBottom()); 126} 127 128void FrameBuilder::deferRenderNodeScene(const std::vector< sp<RenderNode> >& nodes, 129 const Rect& contentDrawBounds) { 130 if (nodes.size() < 1) return; 131 if (nodes.size() == 1) { 132 if (!nodes[0]->nothingToDraw()) { 133 deferRenderNode(*nodes[0]); 134 } 135 return; 136 } 137 // It there are multiple render nodes, they are laid out as follows: 138 // #0 - backdrop (content + caption) 139 // #1 - content (local bounds are at (0,0), will be translated and clipped to backdrop) 140 // #2 - additional overlay nodes 141 // Usually the backdrop cannot be seen since it will be entirely covered by the content. While 142 // resizing however it might become partially visible. The following render loop will crop the 143 // backdrop against the content and draw the remaining part of it. It will then draw the content 144 // cropped to the backdrop (since that indicates a shrinking of the window). 145 // 146 // Additional nodes will be drawn on top with no particular clipping semantics. 147 148 // Usually the contents bounds should be mContentDrawBounds - however - we will 149 // move it towards the fixed edge to give it a more stable appearance (for the moment). 150 // If there is no content bounds we ignore the layering as stated above and start with 2. 151 152 // Backdrop bounds in render target space 153 const Rect backdrop = nodeBounds(*nodes[0]); 154 155 // Bounds that content will fill in render target space (note content node bounds may be bigger) 156 Rect content(contentDrawBounds.getWidth(), contentDrawBounds.getHeight()); 157 content.translate(backdrop.left, backdrop.top); 158 if (!content.contains(backdrop) && !nodes[0]->nothingToDraw()) { 159 // Content doesn't entirely overlap backdrop, so fill around content (right/bottom) 160 161 // Note: in the future, if content doesn't snap to backdrop's left/top, this may need to 162 // also fill left/top. Currently, both 2up and freeform position content at the top/left of 163 // the backdrop, so this isn't necessary. 164 if (content.right < backdrop.right) { 165 // draw backdrop to right side of content 166 deferRenderNode(0, 0, Rect(content.right, backdrop.top, 167 backdrop.right, backdrop.bottom), *nodes[0]); 168 } 169 if (content.bottom < backdrop.bottom) { 170 // draw backdrop to bottom of content 171 // Note: bottom fill uses content left/right, to avoid overdrawing left/right fill 172 deferRenderNode(0, 0, Rect(content.left, content.bottom, 173 content.right, backdrop.bottom), *nodes[0]); 174 } 175 } 176 177 if (!backdrop.isEmpty()) { 178 // content node translation to catch up with backdrop 179 float dx = contentDrawBounds.left - backdrop.left; 180 float dy = contentDrawBounds.top - backdrop.top; 181 182 Rect contentLocalClip = backdrop; 183 contentLocalClip.translate(dx, dy); 184 deferRenderNode(-dx, -dy, contentLocalClip, *nodes[1]); 185 } else { 186 deferRenderNode(*nodes[1]); 187 } 188 189 // remaining overlay nodes, simply defer 190 for (size_t index = 2; index < nodes.size(); index++) { 191 if (!nodes[index]->nothingToDraw()) { 192 deferRenderNode(*nodes[index]); 193 } 194 } 195} 196 197void FrameBuilder::onViewportInitialized() {} 198 199void FrameBuilder::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {} 200 201void FrameBuilder::deferNodePropsAndOps(RenderNode& node) { 202 const RenderProperties& properties = node.properties(); 203 const Outline& outline = properties.getOutline(); 204 if (properties.getAlpha() <= 0 205 || (outline.getShouldClip() && outline.isEmpty()) 206 || properties.getScaleX() == 0 207 || properties.getScaleY() == 0) { 208 return; // rejected 209 } 210 211 if (properties.getLeft() != 0 || properties.getTop() != 0) { 212 mCanvasState.translate(properties.getLeft(), properties.getTop()); 213 } 214 if (properties.getStaticMatrix()) { 215 mCanvasState.concatMatrix(*properties.getStaticMatrix()); 216 } else if (properties.getAnimationMatrix()) { 217 mCanvasState.concatMatrix(*properties.getAnimationMatrix()); 218 } 219 if (properties.hasTransformMatrix()) { 220 if (properties.isTransformTranslateOnly()) { 221 mCanvasState.translate(properties.getTranslationX(), properties.getTranslationY()); 222 } else { 223 mCanvasState.concatMatrix(*properties.getTransformMatrix()); 224 } 225 } 226 227 const int width = properties.getWidth(); 228 const int height = properties.getHeight(); 229 230 Rect saveLayerBounds; // will be set to non-empty if saveLayer needed 231 const bool isLayer = properties.effectiveLayerType() != LayerType::None; 232 int clipFlags = properties.getClippingFlags(); 233 if (properties.getAlpha() < 1) { 234 if (isLayer) { 235 clipFlags &= ~CLIP_TO_BOUNDS; // bounds clipping done by layer 236 } 237 if (CC_LIKELY(isLayer || !properties.getHasOverlappingRendering())) { 238 // simply scale rendering content's alpha 239 mCanvasState.scaleAlpha(properties.getAlpha()); 240 } else { 241 // schedule saveLayer by initializing saveLayerBounds 242 saveLayerBounds.set(0, 0, width, height); 243 if (clipFlags) { 244 properties.getClippingRectForFlags(clipFlags, &saveLayerBounds); 245 clipFlags = 0; // all clipping done by savelayer 246 } 247 } 248 249 if (CC_UNLIKELY(ATRACE_ENABLED() && properties.promotedToLayer())) { 250 // pretend alpha always causes savelayer to warn about 251 // performance problem affecting old versions 252 ATRACE_FORMAT("%s alpha caused saveLayer %dx%d", node.getName(), width, height); 253 } 254 } 255 if (clipFlags) { 256 Rect clipRect; 257 properties.getClippingRectForFlags(clipFlags, &clipRect); 258 mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom, 259 SkRegion::kIntersect_Op); 260 } 261 262 if (properties.getRevealClip().willClip()) { 263 Rect bounds; 264 properties.getRevealClip().getBounds(&bounds); 265 mCanvasState.setClippingRoundRect(mAllocator, 266 bounds, properties.getRevealClip().getRadius()); 267 } else if (properties.getOutline().willClip()) { 268 mCanvasState.setClippingOutline(mAllocator, &(properties.getOutline())); 269 } 270 271 bool quickRejected = mCanvasState.currentSnapshot()->getRenderTargetClip().isEmpty() 272 || (properties.getClipToBounds() 273 && mCanvasState.quickRejectConservative(0, 0, width, height)); 274 if (!quickRejected) { 275 // not rejected, so defer render as either Layer, or direct (possibly wrapped in saveLayer) 276 if (node.getLayer()) { 277 // HW layer 278 LayerOp* drawLayerOp = mAllocator.create_trivial<LayerOp>(node); 279 BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp); 280 if (bakedOpState) { 281 // Node's layer already deferred, schedule it to render into parent layer 282 currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap); 283 } 284 } else if (CC_UNLIKELY(!saveLayerBounds.isEmpty())) { 285 // draw DisplayList contents within temporary, since persisted layer could not be used. 286 // (temp layers are clipped to viewport, since they don't persist offscreen content) 287 SkPaint saveLayerPaint; 288 saveLayerPaint.setAlpha(properties.getAlpha()); 289 deferBeginLayerOp(*mAllocator.create_trivial<BeginLayerOp>( 290 saveLayerBounds, 291 Matrix4::identity(), 292 nullptr, // no record-time clip - need only respect defer-time one 293 &saveLayerPaint)); 294 deferNodeOps(node); 295 deferEndLayerOp(*mAllocator.create_trivial<EndLayerOp>()); 296 } else { 297 deferNodeOps(node); 298 } 299 } 300} 301 302typedef key_value_pair_t<float, const RenderNodeOp*> ZRenderNodeOpPair; 303 304template <typename V> 305static void buildZSortedChildList(V* zTranslatedNodes, 306 const DisplayList& displayList, const DisplayList::Chunk& chunk) { 307 if (chunk.beginChildIndex == chunk.endChildIndex) return; 308 309 for (size_t i = chunk.beginChildIndex; i < chunk.endChildIndex; i++) { 310 RenderNodeOp* childOp = displayList.getChildren()[i]; 311 RenderNode* child = childOp->renderNode; 312 float childZ = child->properties().getZ(); 313 314 if (!MathUtils::isZero(childZ) && chunk.reorderChildren) { 315 zTranslatedNodes->push_back(ZRenderNodeOpPair(childZ, childOp)); 316 childOp->skipInOrderDraw = true; 317 } else if (!child->properties().getProjectBackwards()) { 318 // regular, in order drawing DisplayList 319 childOp->skipInOrderDraw = false; 320 } 321 } 322 323 // Z sort any 3d children (stable-ness makes z compare fall back to standard drawing order) 324 std::stable_sort(zTranslatedNodes->begin(), zTranslatedNodes->end()); 325} 326 327template <typename V> 328static size_t findNonNegativeIndex(const V& zTranslatedNodes) { 329 for (size_t i = 0; i < zTranslatedNodes.size(); i++) { 330 if (zTranslatedNodes[i].key >= 0.0f) return i; 331 } 332 return zTranslatedNodes.size(); 333} 334 335template <typename V> 336void FrameBuilder::defer3dChildren(const ClipBase* reorderClip, ChildrenSelectMode mode, 337 const V& zTranslatedNodes) { 338 const int size = zTranslatedNodes.size(); 339 if (size == 0 340 || (mode == ChildrenSelectMode::Negative&& zTranslatedNodes[0].key > 0.0f) 341 || (mode == ChildrenSelectMode::Positive && zTranslatedNodes[size - 1].key < 0.0f)) { 342 // no 3d children to draw 343 return; 344 } 345 346 /** 347 * Draw shadows and (potential) casters mostly in order, but allow the shadows of casters 348 * with very similar Z heights to draw together. 349 * 350 * This way, if Views A & B have the same Z height and are both casting shadows, the shadows are 351 * underneath both, and neither's shadow is drawn on top of the other. 352 */ 353 const size_t nonNegativeIndex = findNonNegativeIndex(zTranslatedNodes); 354 size_t drawIndex, shadowIndex, endIndex; 355 if (mode == ChildrenSelectMode::Negative) { 356 drawIndex = 0; 357 endIndex = nonNegativeIndex; 358 shadowIndex = endIndex; // draw no shadows 359 } else { 360 drawIndex = nonNegativeIndex; 361 endIndex = size; 362 shadowIndex = drawIndex; // potentially draw shadow for each pos Z child 363 } 364 365 float lastCasterZ = 0.0f; 366 while (shadowIndex < endIndex || drawIndex < endIndex) { 367 if (shadowIndex < endIndex) { 368 const RenderNodeOp* casterNodeOp = zTranslatedNodes[shadowIndex].value; 369 const float casterZ = zTranslatedNodes[shadowIndex].key; 370 // attempt to render the shadow if the caster about to be drawn is its caster, 371 // OR if its caster's Z value is similar to the previous potential caster 372 if (shadowIndex == drawIndex || casterZ - lastCasterZ < 0.1f) { 373 deferShadow(reorderClip, *casterNodeOp); 374 375 lastCasterZ = casterZ; // must do this even if current caster not casting a shadow 376 shadowIndex++; 377 continue; 378 } 379 } 380 381 const RenderNodeOp* childOp = zTranslatedNodes[drawIndex].value; 382 deferRenderNodeOpImpl(*childOp); 383 drawIndex++; 384 } 385} 386 387void FrameBuilder::deferShadow(const ClipBase* reorderClip, const RenderNodeOp& casterNodeOp) { 388 auto& node = *casterNodeOp.renderNode; 389 auto& properties = node.properties(); 390 391 if (properties.getAlpha() <= 0.0f 392 || properties.getOutline().getAlpha() <= 0.0f 393 || !properties.getOutline().getPath() 394 || properties.getScaleX() == 0 395 || properties.getScaleY() == 0) { 396 // no shadow to draw 397 return; 398 } 399 400 const SkPath* casterOutlinePath = properties.getOutline().getPath(); 401 const SkPath* revealClipPath = properties.getRevealClip().getPath(); 402 if (revealClipPath && revealClipPath->isEmpty()) return; 403 404 float casterAlpha = properties.getAlpha() * properties.getOutline().getAlpha(); 405 406 // holds temporary SkPath to store the result of intersections 407 SkPath* frameAllocatedPath = nullptr; 408 const SkPath* casterPath = casterOutlinePath; 409 410 // intersect the shadow-casting path with the reveal, if present 411 if (revealClipPath) { 412 frameAllocatedPath = createFrameAllocatedPath(); 413 414 Op(*casterPath, *revealClipPath, kIntersect_SkPathOp, frameAllocatedPath); 415 casterPath = frameAllocatedPath; 416 } 417 418 // intersect the shadow-casting path with the clipBounds, if present 419 if (properties.getClippingFlags() & CLIP_TO_CLIP_BOUNDS) { 420 if (!frameAllocatedPath) { 421 frameAllocatedPath = createFrameAllocatedPath(); 422 } 423 Rect clipBounds; 424 properties.getClippingRectForFlags(CLIP_TO_CLIP_BOUNDS, &clipBounds); 425 SkPath clipBoundsPath; 426 clipBoundsPath.addRect(clipBounds.left, clipBounds.top, 427 clipBounds.right, clipBounds.bottom); 428 429 Op(*casterPath, clipBoundsPath, kIntersect_SkPathOp, frameAllocatedPath); 430 casterPath = frameAllocatedPath; 431 } 432 433 // apply reorder clip to shadow, so it respects clip at beginning of reorderable chunk 434 int restoreTo = mCanvasState.save(SaveFlags::MatrixClip); 435 mCanvasState.writableSnapshot()->applyClip(reorderClip, 436 *mCanvasState.currentSnapshot()->transform); 437 if (CC_LIKELY(!mCanvasState.getRenderTargetClipBounds().isEmpty())) { 438 Matrix4 shadowMatrixXY(casterNodeOp.localMatrix); 439 Matrix4 shadowMatrixZ(casterNodeOp.localMatrix); 440 node.applyViewPropertyTransforms(shadowMatrixXY, false); 441 node.applyViewPropertyTransforms(shadowMatrixZ, true); 442 443 sp<TessellationCache::ShadowTask> task = mCaches.tessellationCache.getShadowTask( 444 mCanvasState.currentTransform(), 445 mCanvasState.getLocalClipBounds(), 446 casterAlpha >= 1.0f, 447 casterPath, 448 &shadowMatrixXY, &shadowMatrixZ, 449 mCanvasState.currentSnapshot()->getRelativeLightCenter(), 450 mLightRadius); 451 ShadowOp* shadowOp = mAllocator.create<ShadowOp>(task, casterAlpha); 452 BakedOpState* bakedOpState = BakedOpState::tryShadowOpConstruct( 453 mAllocator, *mCanvasState.writableSnapshot(), shadowOp); 454 if (CC_LIKELY(bakedOpState)) { 455 currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Shadow); 456 } 457 } 458 mCanvasState.restoreToCount(restoreTo); 459} 460 461void FrameBuilder::deferProjectedChildren(const RenderNode& renderNode) { 462 int count = mCanvasState.save(SaveFlags::MatrixClip); 463 const SkPath* projectionReceiverOutline = renderNode.properties().getOutline().getPath(); 464 465 SkPath transformedMaskPath; // on stack, since BakedOpState makes a deep copy 466 if (projectionReceiverOutline) { 467 // transform the mask for this projector into render target space 468 // TODO: consider combining both transforms by stashing transform instead of applying 469 SkMatrix skCurrentTransform; 470 mCanvasState.currentTransform()->copyTo(skCurrentTransform); 471 projectionReceiverOutline->transform( 472 skCurrentTransform, 473 &transformedMaskPath); 474 mCanvasState.setProjectionPathMask(mAllocator, &transformedMaskPath); 475 } 476 477 for (size_t i = 0; i < renderNode.mProjectedNodes.size(); i++) { 478 RenderNodeOp* childOp = renderNode.mProjectedNodes[i]; 479 RenderNode& childNode = *childOp->renderNode; 480 481 // Draw child if it has content, but ignore state in childOp - matrix already applied to 482 // transformFromCompositingAncestor, and record-time clip is ignored when projecting 483 if (!childNode.nothingToDraw()) { 484 int restoreTo = mCanvasState.save(SaveFlags::MatrixClip); 485 486 // Apply transform between ancestor and projected descendant 487 mCanvasState.concatMatrix(childOp->transformFromCompositingAncestor); 488 489 deferNodePropsAndOps(childNode); 490 491 mCanvasState.restoreToCount(restoreTo); 492 } 493 } 494 mCanvasState.restoreToCount(count); 495} 496 497/** 498 * Used to define a list of lambdas referencing private FrameBuilder::onXX::defer() methods. 499 * 500 * This allows opIds embedded in the RecordedOps to be used for dispatching to these lambdas. 501 * E.g. a BitmapOp op then would be dispatched to FrameBuilder::onBitmapOp(const BitmapOp&) 502 */ 503#define OP_RECEIVER(Type) \ 504 [](FrameBuilder& frameBuilder, const RecordedOp& op) { frameBuilder.defer##Type(static_cast<const Type&>(op)); }, 505void FrameBuilder::deferNodeOps(const RenderNode& renderNode) { 506 typedef void (*OpDispatcher) (FrameBuilder& frameBuilder, const RecordedOp& op); 507 static OpDispatcher receivers[] = BUILD_DEFERRABLE_OP_LUT(OP_RECEIVER); 508 509 // can't be null, since DL=null node rejection happens before deferNodePropsAndOps 510 const DisplayList& displayList = *(renderNode.getDisplayList()); 511 for (auto& chunk : displayList.getChunks()) { 512 FatVector<ZRenderNodeOpPair, 16> zTranslatedNodes; 513 buildZSortedChildList(&zTranslatedNodes, displayList, chunk); 514 515 defer3dChildren(chunk.reorderClip, ChildrenSelectMode::Negative, zTranslatedNodes); 516 for (size_t opIndex = chunk.beginOpIndex; opIndex < chunk.endOpIndex; opIndex++) { 517 const RecordedOp* op = displayList.getOps()[opIndex]; 518 receivers[op->opId](*this, *op); 519 520 if (CC_UNLIKELY(!renderNode.mProjectedNodes.empty() 521 && displayList.projectionReceiveIndex >= 0 522 && static_cast<int>(opIndex) == displayList.projectionReceiveIndex)) { 523 deferProjectedChildren(renderNode); 524 } 525 } 526 defer3dChildren(chunk.reorderClip, ChildrenSelectMode::Positive, zTranslatedNodes); 527 } 528} 529 530void FrameBuilder::deferRenderNodeOpImpl(const RenderNodeOp& op) { 531 if (op.renderNode->nothingToDraw()) return; 532 int count = mCanvasState.save(SaveFlags::MatrixClip); 533 534 // apply state from RecordedOp (clip first, since op's clip is transformed by current matrix) 535 mCanvasState.writableSnapshot()->applyClip(op.localClip, 536 *mCanvasState.currentSnapshot()->transform); 537 mCanvasState.concatMatrix(op.localMatrix); 538 539 // then apply state from node properties, and defer ops 540 deferNodePropsAndOps(*op.renderNode); 541 542 mCanvasState.restoreToCount(count); 543} 544 545void FrameBuilder::deferRenderNodeOp(const RenderNodeOp& op) { 546 if (!op.skipInOrderDraw) { 547 deferRenderNodeOpImpl(op); 548 } 549} 550 551/** 552 * Defers an unmergeable, strokeable op, accounting correctly 553 * for paint's style on the bounds being computed. 554 */ 555BakedOpState* FrameBuilder::deferStrokeableOp(const RecordedOp& op, batchid_t batchId, 556 BakedOpState::StrokeBehavior strokeBehavior) { 557 // Note: here we account for stroke when baking the op 558 BakedOpState* bakedState = BakedOpState::tryStrokeableOpConstruct( 559 mAllocator, *mCanvasState.writableSnapshot(), op, strokeBehavior); 560 if (!bakedState) return nullptr; // quick rejected 561 562 if (op.opId == RecordedOpId::RectOp && op.paint->getStyle() != SkPaint::kStroke_Style) { 563 bakedState->setupOpacity(op.paint); 564 } 565 566 currentLayer().deferUnmergeableOp(mAllocator, bakedState, batchId); 567 return bakedState; 568} 569 570/** 571 * Returns batch id for tessellatable shapes, based on paint. Checks to see if path effect/AA will 572 * be used, since they trigger significantly different rendering paths. 573 * 574 * Note: not used for lines/points, since they don't currently support path effects. 575 */ 576static batchid_t tessBatchId(const RecordedOp& op) { 577 const SkPaint& paint = *(op.paint); 578 return paint.getPathEffect() 579 ? OpBatchType::AlphaMaskTexture 580 : (paint.isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices); 581} 582 583void FrameBuilder::deferArcOp(const ArcOp& op) { 584 deferStrokeableOp(op, tessBatchId(op)); 585} 586 587static bool hasMergeableClip(const BakedOpState& state) { 588 return state.computedState.clipState 589 || state.computedState.clipState->mode == ClipMode::Rectangle; 590} 591 592void FrameBuilder::deferBitmapOp(const BitmapOp& op) { 593 BakedOpState* bakedState = tryBakeOpState(op); 594 if (!bakedState) return; // quick rejected 595 596 if (op.bitmap->isOpaque()) { 597 bakedState->setupOpacity(op.paint); 598 } 599 600 // Don't merge non-simply transformed or neg scale ops, SET_TEXTURE doesn't handle rotation 601 // Don't merge A8 bitmaps - the paint's color isn't compared by mergeId, or in 602 // MergingDrawBatch::canMergeWith() 603 if (bakedState->computedState.transform.isSimple() 604 && bakedState->computedState.transform.positiveScale() 605 && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode 606 && op.bitmap->colorType() != kAlpha_8_SkColorType 607 && hasMergeableClip(*bakedState)) { 608 mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID()); 609 // TODO: AssetAtlas in mergeId 610 currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::Bitmap, mergeId); 611 } else { 612 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap); 613 } 614} 615 616void FrameBuilder::deferBitmapMeshOp(const BitmapMeshOp& op) { 617 BakedOpState* bakedState = tryBakeOpState(op); 618 if (!bakedState) return; // quick rejected 619 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap); 620} 621 622void FrameBuilder::deferBitmapRectOp(const BitmapRectOp& op) { 623 BakedOpState* bakedState = tryBakeOpState(op); 624 if (!bakedState) return; // quick rejected 625 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap); 626} 627 628void FrameBuilder::deferVectorDrawableOp(const VectorDrawableOp& op) { 629 const SkBitmap& bitmap = op.vectorDrawable->getBitmapUpdateIfDirty(); 630 SkPaint* paint = op.vectorDrawable->getPaint(); 631 const BitmapRectOp* resolvedOp = mAllocator.create_trivial<BitmapRectOp>(op.unmappedBounds, 632 op.localMatrix, 633 op.localClip, 634 paint, 635 &bitmap, 636 Rect(bitmap.width(), bitmap.height())); 637 deferBitmapRectOp(*resolvedOp); 638} 639 640void FrameBuilder::deferCirclePropsOp(const CirclePropsOp& op) { 641 // allocate a temporary oval op (with mAllocator, so it persists until render), so the 642 // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple. 643 float x = *(op.x); 644 float y = *(op.y); 645 float radius = *(op.radius); 646 Rect unmappedBounds(x - radius, y - radius, x + radius, y + radius); 647 const OvalOp* resolvedOp = mAllocator.create_trivial<OvalOp>( 648 unmappedBounds, 649 op.localMatrix, 650 op.localClip, 651 op.paint); 652 deferOvalOp(*resolvedOp); 653} 654 655void FrameBuilder::deferColorOp(const ColorOp& op) { 656 BakedOpState* bakedState = tryBakeUnboundedOpState(op); 657 if (!bakedState) return; // quick rejected 658 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Vertices); 659} 660 661void FrameBuilder::deferFunctorOp(const FunctorOp& op) { 662 BakedOpState* bakedState = tryBakeUnboundedOpState(op); 663 if (!bakedState) return; // quick rejected 664 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Functor); 665} 666 667void FrameBuilder::deferLinesOp(const LinesOp& op) { 668 batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices; 669 deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced); 670} 671 672void FrameBuilder::deferOvalOp(const OvalOp& op) { 673 deferStrokeableOp(op, tessBatchId(op)); 674} 675 676void FrameBuilder::deferPatchOp(const PatchOp& op) { 677 BakedOpState* bakedState = tryBakeOpState(op); 678 if (!bakedState) return; // quick rejected 679 680 if (bakedState->computedState.transform.isPureTranslate() 681 && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode 682 && hasMergeableClip(*bakedState)) { 683 mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID()); 684 // TODO: AssetAtlas in mergeId 685 686 // Only use the MergedPatch batchId when merged, so Bitmap+Patch don't try to merge together 687 currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::MergedPatch, mergeId); 688 } else { 689 // Use Bitmap batchId since Bitmap+Patch use same shader 690 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap); 691 } 692} 693 694void FrameBuilder::deferPathOp(const PathOp& op) { 695 auto state = deferStrokeableOp(op, OpBatchType::AlphaMaskTexture); 696 if (CC_LIKELY(state)) { 697 mCaches.pathCache.precache(op.path, op.paint); 698 } 699} 700 701void FrameBuilder::deferPointsOp(const PointsOp& op) { 702 batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices; 703 deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced); 704} 705 706void FrameBuilder::deferRectOp(const RectOp& op) { 707 deferStrokeableOp(op, tessBatchId(op)); 708} 709 710void FrameBuilder::deferRoundRectOp(const RoundRectOp& op) { 711 auto state = deferStrokeableOp(op, tessBatchId(op)); 712 if (CC_LIKELY(state && !op.paint->getPathEffect())) { 713 // TODO: consider storing tessellation task in BakedOpState 714 mCaches.tessellationCache.precacheRoundRect(state->computedState.transform, *(op.paint), 715 op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight(), op.rx, op.ry); 716 } 717} 718 719void FrameBuilder::deferRoundRectPropsOp(const RoundRectPropsOp& op) { 720 // allocate a temporary round rect op (with mAllocator, so it persists until render), so the 721 // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple. 722 const RoundRectOp* resolvedOp = mAllocator.create_trivial<RoundRectOp>( 723 Rect(*(op.left), *(op.top), *(op.right), *(op.bottom)), 724 op.localMatrix, 725 op.localClip, 726 op.paint, *op.rx, *op.ry); 727 deferRoundRectOp(*resolvedOp); 728} 729 730void FrameBuilder::deferSimpleRectsOp(const SimpleRectsOp& op) { 731 BakedOpState* bakedState = tryBakeOpState(op); 732 if (!bakedState) return; // quick rejected 733 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Vertices); 734} 735 736static batchid_t textBatchId(const SkPaint& paint) { 737 // TODO: better handling of shader (since we won't care about color then) 738 return paint.getColor() == SK_ColorBLACK ? OpBatchType::Text : OpBatchType::ColorText; 739} 740 741void FrameBuilder::deferTextOp(const TextOp& op) { 742 BakedOpState* bakedState = BakedOpState::tryStrokeableOpConstruct( 743 mAllocator, *mCanvasState.writableSnapshot(), op, 744 BakedOpState::StrokeBehavior::StyleDefined); 745 if (!bakedState) return; // quick rejected 746 747 batchid_t batchId = textBatchId(*(op.paint)); 748 if (bakedState->computedState.transform.isPureTranslate() 749 && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode 750 && hasMergeableClip(*bakedState)) { 751 mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.paint->getColor()); 752 currentLayer().deferMergeableOp(mAllocator, bakedState, batchId, mergeId); 753 } else { 754 currentLayer().deferUnmergeableOp(mAllocator, bakedState, batchId); 755 } 756 757 FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer(); 758 auto& totalTransform = bakedState->computedState.transform; 759 if (totalTransform.isPureTranslate() || totalTransform.isPerspective()) { 760 fontRenderer.precache(op.paint, op.glyphs, op.glyphCount, SkMatrix::I()); 761 } else { 762 // Partial transform case, see BakedOpDispatcher::renderTextOp 763 float sx, sy; 764 totalTransform.decomposeScale(sx, sy); 765 fontRenderer.precache(op.paint, op.glyphs, op.glyphCount, SkMatrix::MakeScale( 766 roundf(std::max(1.0f, sx)), 767 roundf(std::max(1.0f, sy)))); 768 } 769} 770 771void FrameBuilder::deferTextOnPathOp(const TextOnPathOp& op) { 772 BakedOpState* bakedState = tryBakeUnboundedOpState(op); 773 if (!bakedState) return; // quick rejected 774 currentLayer().deferUnmergeableOp(mAllocator, bakedState, textBatchId(*(op.paint))); 775 776 mCaches.fontRenderer.getFontRenderer().precache( 777 op.paint, op.glyphs, op.glyphCount, SkMatrix::I()); 778} 779 780void FrameBuilder::deferTextureLayerOp(const TextureLayerOp& op) { 781 if (CC_UNLIKELY(!op.layer->isRenderable())) return; 782 783 const TextureLayerOp* textureLayerOp = &op; 784 // Now safe to access transform (which was potentially unready at record time) 785 if (!op.layer->getTransform().isIdentity()) { 786 // non-identity transform present, so 'inject it' into op by copying + replacing matrix 787 Matrix4 combinedMatrix(op.localMatrix); 788 combinedMatrix.multiply(op.layer->getTransform()); 789 textureLayerOp = mAllocator.create<TextureLayerOp>(op, combinedMatrix); 790 } 791 BakedOpState* bakedState = tryBakeOpState(*textureLayerOp); 792 793 if (!bakedState) return; // quick rejected 794 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::TextureLayer); 795} 796 797void FrameBuilder::saveForLayer(uint32_t layerWidth, uint32_t layerHeight, 798 float contentTranslateX, float contentTranslateY, 799 const Rect& repaintRect, 800 const Vector3& lightCenter, 801 const BeginLayerOp* beginLayerOp, RenderNode* renderNode) { 802 mCanvasState.save(SaveFlags::MatrixClip); 803 mCanvasState.writableSnapshot()->initializeViewport(layerWidth, layerHeight); 804 mCanvasState.writableSnapshot()->roundRectClipState = nullptr; 805 mCanvasState.writableSnapshot()->setRelativeLightCenter(lightCenter); 806 mCanvasState.writableSnapshot()->transform->loadTranslate( 807 contentTranslateX, contentTranslateY, 0); 808 mCanvasState.writableSnapshot()->setClip( 809 repaintRect.left, repaintRect.top, repaintRect.right, repaintRect.bottom); 810 811 // create a new layer repaint, and push its index on the stack 812 mLayerStack.push_back(mLayerBuilders.size()); 813 auto newFbo = mAllocator.create<LayerBuilder>(layerWidth, layerHeight, 814 repaintRect, beginLayerOp, renderNode); 815 mLayerBuilders.push_back(newFbo); 816} 817 818void FrameBuilder::restoreForLayer() { 819 // restore canvas, and pop finished layer off of the stack 820 mCanvasState.restore(); 821 mLayerStack.pop_back(); 822} 823 824// TODO: defer time rejection (when bounds become empty) + tests 825// Option - just skip layers with no bounds at playback + defer? 826void FrameBuilder::deferBeginLayerOp(const BeginLayerOp& op) { 827 uint32_t layerWidth = (uint32_t) op.unmappedBounds.getWidth(); 828 uint32_t layerHeight = (uint32_t) op.unmappedBounds.getHeight(); 829 830 auto previous = mCanvasState.currentSnapshot(); 831 Vector3 lightCenter = previous->getRelativeLightCenter(); 832 833 // Combine all transforms used to present saveLayer content: 834 // parent content transform * canvas transform * bounds offset 835 Matrix4 contentTransform(*(previous->transform)); 836 contentTransform.multiply(op.localMatrix); 837 contentTransform.translate(op.unmappedBounds.left, op.unmappedBounds.top); 838 839 Matrix4 inverseContentTransform; 840 inverseContentTransform.loadInverse(contentTransform); 841 842 // map the light center into layer-relative space 843 inverseContentTransform.mapPoint3d(lightCenter); 844 845 // Clip bounds of temporary layer to parent's clip rect, so: 846 Rect saveLayerBounds(layerWidth, layerHeight); 847 // 1) transform Rect(width, height) into parent's space 848 // note: left/top offsets put in contentTransform above 849 contentTransform.mapRect(saveLayerBounds); 850 // 2) intersect with parent's clip 851 saveLayerBounds.doIntersect(previous->getRenderTargetClip()); 852 // 3) and transform back 853 inverseContentTransform.mapRect(saveLayerBounds); 854 saveLayerBounds.doIntersect(Rect(layerWidth, layerHeight)); 855 saveLayerBounds.roundOut(); 856 857 // if bounds are reduced, will clip the layer's area by reducing required bounds... 858 layerWidth = saveLayerBounds.getWidth(); 859 layerHeight = saveLayerBounds.getHeight(); 860 // ...and shifting drawing content to account for left/top side clipping 861 float contentTranslateX = -saveLayerBounds.left; 862 float contentTranslateY = -saveLayerBounds.top; 863 864 saveForLayer(layerWidth, layerHeight, 865 contentTranslateX, contentTranslateY, 866 Rect(layerWidth, layerHeight), 867 lightCenter, 868 &op, nullptr); 869} 870 871void FrameBuilder::deferEndLayerOp(const EndLayerOp& /* ignored */) { 872 const BeginLayerOp& beginLayerOp = *currentLayer().beginLayerOp; 873 int finishedLayerIndex = mLayerStack.back(); 874 875 restoreForLayer(); 876 877 // record the draw operation into the previous layer's list of draw commands 878 // uses state from the associated beginLayerOp, since it has all the state needed for drawing 879 LayerOp* drawLayerOp = mAllocator.create_trivial<LayerOp>( 880 beginLayerOp.unmappedBounds, 881 beginLayerOp.localMatrix, 882 beginLayerOp.localClip, 883 beginLayerOp.paint, 884 &(mLayerBuilders[finishedLayerIndex]->offscreenBuffer)); 885 BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp); 886 887 if (bakedOpState) { 888 // Layer will be drawn into parent layer (which is now current, since we popped mLayerStack) 889 currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap); 890 } else { 891 // Layer won't be drawn - delete its drawing batches to prevent it from doing any work 892 // TODO: need to prevent any render work from being done 893 // - create layerop earlier for reject purposes? 894 mLayerBuilders[finishedLayerIndex]->clear(); 895 return; 896 } 897} 898 899void FrameBuilder::deferBeginUnclippedLayerOp(const BeginUnclippedLayerOp& op) { 900 Matrix4 boundsTransform(*(mCanvasState.currentSnapshot()->transform)); 901 boundsTransform.multiply(op.localMatrix); 902 903 Rect dstRect(op.unmappedBounds); 904 boundsTransform.mapRect(dstRect); 905 dstRect.doIntersect(mCanvasState.currentSnapshot()->getRenderTargetClip()); 906 907 if (dstRect.isEmpty()) { 908 // Unclipped layer rejected - push a null op, so next EndUnclippedLayerOp is ignored 909 currentLayer().activeUnclippedSaveLayers.push_back(nullptr); 910 } else { 911 // Allocate a holding position for the layer object (copyTo will produce, copyFrom will consume) 912 OffscreenBuffer** layerHandle = mAllocator.create<OffscreenBuffer*>(nullptr); 913 914 /** 915 * First, defer an operation to copy out the content from the rendertarget into a layer. 916 */ 917 auto copyToOp = mAllocator.create_trivial<CopyToLayerOp>(op, layerHandle); 918 BakedOpState* bakedState = BakedOpState::directConstruct(mAllocator, 919 &(currentLayer().repaintClip), dstRect, *copyToOp); 920 currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::CopyToLayer); 921 922 /** 923 * Defer a clear rect, so that clears from multiple unclipped layers can be drawn 924 * both 1) simultaneously, and 2) as long after the copyToLayer executes as possible 925 */ 926 currentLayer().deferLayerClear(dstRect); 927 928 /** 929 * And stash an operation to copy that layer back under the rendertarget until 930 * a balanced EndUnclippedLayerOp is seen 931 */ 932 auto copyFromOp = mAllocator.create_trivial<CopyFromLayerOp>(op, layerHandle); 933 bakedState = BakedOpState::directConstruct(mAllocator, 934 &(currentLayer().repaintClip), dstRect, *copyFromOp); 935 currentLayer().activeUnclippedSaveLayers.push_back(bakedState); 936 } 937} 938 939void FrameBuilder::deferEndUnclippedLayerOp(const EndUnclippedLayerOp& /* ignored */) { 940 LOG_ALWAYS_FATAL_IF(currentLayer().activeUnclippedSaveLayers.empty(), "no layer to end!"); 941 942 BakedOpState* copyFromLayerOp = currentLayer().activeUnclippedSaveLayers.back(); 943 currentLayer().activeUnclippedSaveLayers.pop_back(); 944 if (copyFromLayerOp) { 945 currentLayer().deferUnmergeableOp(mAllocator, copyFromLayerOp, OpBatchType::CopyFromLayer); 946 } 947} 948 949void FrameBuilder::finishDefer() { 950 mCaches.fontRenderer.endPrecaching(); 951} 952 953} // namespace uirenderer 954} // namespace android 955