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