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