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