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