Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 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 "RenderNodeDrawable.h" |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 18 | #include <SkPaintFilterCanvas.h> |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 19 | #include "RenderNode.h" |
| 20 | #include "SkiaDisplayList.h" |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 21 | #include "SkiaPipeline.h" |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 22 | #include "utils/TraceUtils.h" |
| 23 | |
Ben Wagner | 1d15533 | 2018-08-20 18:36:05 -0400 | [diff] [blame] | 24 | #include <optional> |
| 25 | |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 26 | namespace android { |
| 27 | namespace uirenderer { |
| 28 | namespace skiapipeline { |
| 29 | |
John Reck | d9d7f12 | 2018-05-03 14:40:56 -0700 | [diff] [blame] | 30 | RenderNodeDrawable::RenderNodeDrawable(RenderNode* node, SkCanvas* canvas, bool composeLayer, |
| 31 | bool inReorderingSection) |
| 32 | : mRenderNode(node) |
| 33 | , mRecordedTransform(canvas->getTotalMatrix()) |
| 34 | , mComposeLayer(composeLayer) |
| 35 | , mInReorderingSection(inReorderingSection) {} |
| 36 | |
| 37 | RenderNodeDrawable::~RenderNodeDrawable() { |
| 38 | // Just here to move the destructor into the cpp file where we can access RenderNode. |
| 39 | |
| 40 | // TODO: Detangle the header nightmare. |
| 41 | } |
| 42 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 43 | void RenderNodeDrawable::drawBackwardsProjectedNodes(SkCanvas* canvas, |
| 44 | const SkiaDisplayList& displayList, |
| 45 | int nestLevel) { |
Stan Iliev | db45a4b | 2016-11-08 14:18:31 -0500 | [diff] [blame] | 46 | LOG_ALWAYS_FATAL_IF(0 == nestLevel && !displayList.mProjectionReceiver); |
| 47 | for (auto& child : displayList.mChildNodes) { |
| 48 | const RenderProperties& childProperties = child.getNodeProperties(); |
| 49 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 50 | // immediate children cannot be projected on their parent |
Stan Iliev | db45a4b | 2016-11-08 14:18:31 -0500 | [diff] [blame] | 51 | if (childProperties.getProjectBackwards() && nestLevel > 0) { |
| 52 | SkAutoCanvasRestore acr2(canvas, true); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 53 | // Apply recorded matrix, which is a total matrix saved at recording time to avoid |
| 54 | // replaying all DL commands. |
Stan Iliev | db45a4b | 2016-11-08 14:18:31 -0500 | [diff] [blame] | 55 | canvas->concat(child.getRecordedMatrix()); |
| 56 | child.drawContent(canvas); |
| 57 | } |
| 58 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 59 | // skip walking sub-nodes if current display list contains a receiver with exception of |
| 60 | // level 0, which is a known receiver |
Stan Iliev | db45a4b | 2016-11-08 14:18:31 -0500 | [diff] [blame] | 61 | if (0 == nestLevel || !displayList.containsProjectionReceiver()) { |
| 62 | SkAutoCanvasRestore acr(canvas, true); |
| 63 | SkMatrix nodeMatrix; |
| 64 | mat4 hwuiMatrix(child.getRecordedMatrix()); |
| 65 | auto childNode = child.getRenderNode(); |
| 66 | childNode->applyViewPropertyTransforms(hwuiMatrix); |
| 67 | hwuiMatrix.copyTo(nodeMatrix); |
| 68 | canvas->concat(nodeMatrix); |
| 69 | SkiaDisplayList* childDisplayList = static_cast<SkiaDisplayList*>( |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 70 | (const_cast<DisplayList*>(childNode->getDisplayList()))); |
Stan Iliev | db45a4b | 2016-11-08 14:18:31 -0500 | [diff] [blame] | 71 | if (childDisplayList) { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 72 | drawBackwardsProjectedNodes(canvas, *childDisplayList, nestLevel + 1); |
Stan Iliev | db45a4b | 2016-11-08 14:18:31 -0500 | [diff] [blame] | 73 | } |
| 74 | } |
| 75 | } |
| 76 | } |
| 77 | |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 78 | static void clipOutline(const Outline& outline, SkCanvas* canvas, const SkRect* pendingClip) { |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 79 | Rect possibleRect; |
| 80 | float radius; |
Derek Sollenberger | f209c06 | 2017-05-26 12:11:34 -0400 | [diff] [blame] | 81 | |
| 82 | /* To match the existing HWUI behavior we only supports rectangles or |
| 83 | * rounded rectangles; passing in a more complicated outline fails silently. |
| 84 | */ |
| 85 | if (!outline.getAsRoundRect(&possibleRect, &radius)) { |
| 86 | if (pendingClip) { |
| 87 | canvas->clipRect(*pendingClip); |
| 88 | } |
| 89 | return; |
| 90 | } |
| 91 | |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 92 | SkRect rect = possibleRect.toSkRect(); |
| 93 | if (radius != 0.0f) { |
| 94 | if (pendingClip && !pendingClip->contains(rect)) { |
| 95 | canvas->clipRect(*pendingClip); |
| 96 | } |
Mike Reed | 6c67f1d | 2016-12-14 10:29:54 -0500 | [diff] [blame] | 97 | canvas->clipRRect(SkRRect::MakeRectXY(rect, radius, radius), SkClipOp::kIntersect, true); |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 98 | } else { |
| 99 | if (pendingClip) { |
| 100 | (void)rect.intersect(*pendingClip); |
| 101 | } |
| 102 | canvas->clipRect(rect); |
| 103 | } |
| 104 | } |
| 105 | |
| 106 | const RenderProperties& RenderNodeDrawable::getNodeProperties() const { |
| 107 | return mRenderNode->properties(); |
| 108 | } |
| 109 | |
| 110 | void RenderNodeDrawable::onDraw(SkCanvas* canvas) { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 111 | // negative and positive Z order are drawn out of order, if this render node drawable is in |
| 112 | // a reordering section |
Stan Iliev | 2f06e8a | 2016-11-02 15:29:03 -0400 | [diff] [blame] | 113 | if ((!mInReorderingSection) || MathUtils::isZero(mRenderNode->properties().getZ())) { |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 114 | this->forceDraw(canvas); |
| 115 | } |
| 116 | } |
| 117 | |
John Reck | f96b284 | 2018-11-29 09:44:10 -0800 | [diff] [blame] | 118 | class MarkDraw { |
| 119 | public: |
| 120 | explicit MarkDraw(SkCanvas& canvas, RenderNode& node) : mCanvas(canvas), mNode(node) { |
| 121 | if (CC_UNLIKELY(Properties::skpCaptureEnabled)) { |
| 122 | mNode.markDrawStart(mCanvas); |
| 123 | } |
| 124 | } |
| 125 | ~MarkDraw() { |
| 126 | if (CC_UNLIKELY(Properties::skpCaptureEnabled)) { |
| 127 | mNode.markDrawEnd(mCanvas); |
| 128 | } |
| 129 | } |
John Reck | 283bb46 | 2018-12-13 16:40:14 -0800 | [diff] [blame^] | 130 | |
John Reck | f96b284 | 2018-11-29 09:44:10 -0800 | [diff] [blame] | 131 | private: |
| 132 | SkCanvas& mCanvas; |
| 133 | RenderNode& mNode; |
| 134 | }; |
| 135 | |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 136 | void RenderNodeDrawable::forceDraw(SkCanvas* canvas) { |
| 137 | RenderNode* renderNode = mRenderNode.get(); |
John Reck | f96b284 | 2018-11-29 09:44:10 -0800 | [diff] [blame] | 138 | MarkDraw _marker{*canvas, *renderNode}; |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 139 | |
| 140 | // We only respect the nothingToDraw check when we are composing a layer. This |
| 141 | // ensures that we paint the layer even if it is not currently visible in the |
| 142 | // event that the properties change and it becomes visible. |
Yuqian Li | 5ebbc8e | 2017-11-29 09:53:06 -0500 | [diff] [blame] | 143 | if ((mProjectedDisplayList == nullptr && !renderNode->isRenderable()) || |
John Reck | 283bb46 | 2018-12-13 16:40:14 -0800 | [diff] [blame^] | 144 | (renderNode->nothingToDraw() && mComposeLayer)) { |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 145 | return; |
| 146 | } |
| 147 | |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 148 | SkiaDisplayList* displayList = (SkiaDisplayList*)renderNode->getDisplayList(); |
| 149 | |
| 150 | SkAutoCanvasRestore acr(canvas, true); |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 151 | const RenderProperties& properties = this->getNodeProperties(); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 152 | // pass this outline to the children that may clip backward projected nodes |
| 153 | displayList->mProjectedOutline = |
| 154 | displayList->containsProjectionReceiver() ? &properties.getOutline() : nullptr; |
Stan Iliev | db45a4b | 2016-11-08 14:18:31 -0500 | [diff] [blame] | 155 | if (!properties.getProjectBackwards()) { |
| 156 | drawContent(canvas); |
| 157 | if (mProjectedDisplayList) { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 158 | acr.restore(); // draw projected children using parent matrix |
Stan Iliev | db45a4b | 2016-11-08 14:18:31 -0500 | [diff] [blame] | 159 | LOG_ALWAYS_FATAL_IF(!mProjectedDisplayList->mProjectedOutline); |
| 160 | const bool shouldClip = mProjectedDisplayList->mProjectedOutline->getPath(); |
| 161 | SkAutoCanvasRestore acr2(canvas, shouldClip); |
Stan Iliev | 54d7032 | 2018-06-14 18:00:10 -0400 | [diff] [blame] | 162 | canvas->setMatrix(mProjectedDisplayList->mParentMatrix); |
Stan Iliev | db45a4b | 2016-11-08 14:18:31 -0500 | [diff] [blame] | 163 | if (shouldClip) { |
| 164 | clipOutline(*mProjectedDisplayList->mProjectedOutline, canvas, nullptr); |
| 165 | } |
| 166 | drawBackwardsProjectedNodes(canvas, *mProjectedDisplayList); |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 167 | } |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 168 | } |
Stan Iliev | db45a4b | 2016-11-08 14:18:31 -0500 | [diff] [blame] | 169 | displayList->mProjectedOutline = nullptr; |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 170 | } |
| 171 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 172 | static bool layerNeedsPaint(const LayerProperties& properties, float alphaMultiplier, |
| 173 | SkPaint* paint) { |
Stan Iliev | 7e100e9 | 2018-01-22 10:36:33 -0500 | [diff] [blame] | 174 | paint->setFilterQuality(kLow_SkFilterQuality); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 175 | if (alphaMultiplier < 1.0f || properties.alpha() < 255 || |
Ben Wagner | c1a8a46 | 2018-07-12 12:41:28 -0400 | [diff] [blame] | 176 | properties.xferMode() != SkBlendMode::kSrcOver || properties.getColorFilter() != nullptr) { |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 177 | paint->setAlpha(properties.alpha() * alphaMultiplier); |
| 178 | paint->setBlendMode(properties.xferMode()); |
Ben Wagner | c1a8a46 | 2018-07-12 12:41:28 -0400 | [diff] [blame] | 179 | paint->setColorFilter(sk_ref_sp(properties.getColorFilter())); |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 180 | return true; |
| 181 | } |
| 182 | return false; |
| 183 | } |
| 184 | |
Stan Iliev | 1843ac7 | 2017-09-20 18:05:35 -0400 | [diff] [blame] | 185 | class AlphaFilterCanvas : public SkPaintFilterCanvas { |
| 186 | public: |
| 187 | AlphaFilterCanvas(SkCanvas* canvas, float alpha) : SkPaintFilterCanvas(canvas), mAlpha(alpha) {} |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 188 | |
Stan Iliev | 1843ac7 | 2017-09-20 18:05:35 -0400 | [diff] [blame] | 189 | protected: |
| 190 | bool onFilter(SkTCopyOnFirstWrite<SkPaint>* paint, Type t) const override { |
Ben Wagner | 1d15533 | 2018-08-20 18:36:05 -0400 | [diff] [blame] | 191 | std::optional<SkPaint> defaultPaint; |
Stan Iliev | 1843ac7 | 2017-09-20 18:05:35 -0400 | [diff] [blame] | 192 | if (!*paint) { |
Ben Wagner | 1d15533 | 2018-08-20 18:36:05 -0400 | [diff] [blame] | 193 | paint->init(defaultPaint.emplace()); |
Stan Iliev | 1843ac7 | 2017-09-20 18:05:35 -0400 | [diff] [blame] | 194 | } |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 195 | paint->writable()->setAlpha((uint8_t)(*paint)->getAlpha() * mAlpha); |
Stan Iliev | 1843ac7 | 2017-09-20 18:05:35 -0400 | [diff] [blame] | 196 | return true; |
| 197 | } |
| 198 | void onDrawDrawable(SkDrawable* drawable, const SkMatrix* matrix) override { |
| 199 | // We unroll the drawable using "this" canvas, so that draw calls contained inside will |
| 200 | // get their alpha applied. THe default SkPaintFilterCanvas::onDrawDrawable does not unroll. |
| 201 | drawable->draw(this, matrix); |
| 202 | } |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 203 | |
Stan Iliev | 1843ac7 | 2017-09-20 18:05:35 -0400 | [diff] [blame] | 204 | private: |
| 205 | float mAlpha; |
| 206 | }; |
| 207 | |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 208 | void RenderNodeDrawable::drawContent(SkCanvas* canvas) const { |
| 209 | RenderNode* renderNode = mRenderNode.get(); |
| 210 | float alphaMultiplier = 1.0f; |
| 211 | const RenderProperties& properties = renderNode->properties(); |
| 212 | |
| 213 | // If we are drawing the contents of layer, we don't want to apply any of |
| 214 | // the RenderNode's properties during this pass. Those will all be applied |
| 215 | // when the layer is composited. |
| 216 | if (mComposeLayer) { |
| 217 | setViewProperties(properties, canvas, &alphaMultiplier); |
| 218 | } |
Stan Iliev | db45a4b | 2016-11-08 14:18:31 -0500 | [diff] [blame] | 219 | SkiaDisplayList* displayList = (SkiaDisplayList*)mRenderNode->getDisplayList(); |
Stan Iliev | 54d7032 | 2018-06-14 18:00:10 -0400 | [diff] [blame] | 220 | displayList->mParentMatrix = canvas->getTotalMatrix(); |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 221 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 222 | // TODO should we let the bound of the drawable do this for us? |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 223 | const SkRect bounds = SkRect::MakeWH(properties.getWidth(), properties.getHeight()); |
| 224 | bool quickRejected = properties.getClipToBounds() && canvas->quickReject(bounds); |
| 225 | if (!quickRejected) { |
| 226 | SkiaDisplayList* displayList = (SkiaDisplayList*)renderNode->getDisplayList(); |
| 227 | const LayerProperties& layerProperties = properties.layerProperties(); |
| 228 | // composing a hardware layer |
| 229 | if (renderNode->getLayerSurface() && mComposeLayer) { |
| 230 | SkASSERT(properties.effectiveLayerType() == LayerType::RenderLayer); |
Stan Iliev | 7e100e9 | 2018-01-22 10:36:33 -0500 | [diff] [blame] | 231 | SkPaint paint; |
| 232 | layerNeedsPaint(layerProperties, alphaMultiplier, &paint); |
Derek Sollenberger | 03e6cff7 | 2017-12-04 15:07:08 -0500 | [diff] [blame] | 233 | |
| 234 | // surfaces for layers are created on LAYER_SIZE boundaries (which are >= layer size) so |
| 235 | // we need to restrict the portion of the surface drawn to the size of the renderNode. |
| 236 | SkASSERT(renderNode->getLayerSurface()->width() >= bounds.width()); |
| 237 | SkASSERT(renderNode->getLayerSurface()->height() >= bounds.height()); |
John Reck | 283bb46 | 2018-12-13 16:40:14 -0800 | [diff] [blame^] | 238 | canvas->drawImageRect(renderNode->getLayerSurface()->makeImageSnapshot().get(), bounds, |
| 239 | bounds, &paint); |
Matt Sarett | 79756be | 2016-11-09 16:13:54 -0500 | [diff] [blame] | 240 | |
Matt Sarett | f58cc92 | 2016-11-14 18:33:38 -0500 | [diff] [blame] | 241 | if (!renderNode->getSkiaLayer()->hasRenderedSinceRepaint) { |
Matt Sarett | 79756be | 2016-11-09 16:13:54 -0500 | [diff] [blame] | 242 | renderNode->getSkiaLayer()->hasRenderedSinceRepaint = true; |
Matt Sarett | f58cc92 | 2016-11-14 18:33:38 -0500 | [diff] [blame] | 243 | if (CC_UNLIKELY(Properties::debugLayersUpdates)) { |
| 244 | SkPaint layerPaint; |
| 245 | layerPaint.setColor(0x7f00ff00); |
| 246 | canvas->drawRect(bounds, layerPaint); |
| 247 | } else if (CC_UNLIKELY(Properties::debugOverdraw)) { |
| 248 | // Render transparent rect to increment overdraw for repaint area. |
| 249 | // This can be "else if" because flashing green on layer updates |
| 250 | // will also increment the overdraw if it happens to be turned on. |
| 251 | SkPaint transparentPaint; |
| 252 | transparentPaint.setColor(SK_ColorTRANSPARENT); |
| 253 | canvas->drawRect(bounds, transparentPaint); |
| 254 | } |
Matt Sarett | 79756be | 2016-11-09 16:13:54 -0500 | [diff] [blame] | 255 | } |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 256 | } else { |
Stan Iliev | 1843ac7 | 2017-09-20 18:05:35 -0400 | [diff] [blame] | 257 | if (alphaMultiplier < 1.0f) { |
| 258 | // Non-layer draw for a view with getHasOverlappingRendering=false, will apply |
| 259 | // the alpha to the paint of each nested draw. |
| 260 | AlphaFilterCanvas alphaCanvas(canvas, alphaMultiplier); |
| 261 | displayList->draw(&alphaCanvas); |
| 262 | } else { |
| 263 | displayList->draw(canvas); |
| 264 | } |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 265 | } |
| 266 | } |
| 267 | } |
| 268 | |
| 269 | void RenderNodeDrawable::setViewProperties(const RenderProperties& properties, SkCanvas* canvas, |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 270 | float* alphaMultiplier) { |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 271 | if (properties.getLeft() != 0 || properties.getTop() != 0) { |
| 272 | canvas->translate(properties.getLeft(), properties.getTop()); |
| 273 | } |
| 274 | if (properties.getStaticMatrix()) { |
| 275 | canvas->concat(*properties.getStaticMatrix()); |
| 276 | } else if (properties.getAnimationMatrix()) { |
| 277 | canvas->concat(*properties.getAnimationMatrix()); |
| 278 | } |
| 279 | if (properties.hasTransformMatrix()) { |
| 280 | if (properties.isTransformTranslateOnly()) { |
| 281 | canvas->translate(properties.getTranslationX(), properties.getTranslationY()); |
| 282 | } else { |
| 283 | canvas->concat(*properties.getTransformMatrix()); |
| 284 | } |
| 285 | } |
| 286 | const bool isLayer = properties.effectiveLayerType() != LayerType::None; |
| 287 | int clipFlags = properties.getClippingFlags(); |
| 288 | if (properties.getAlpha() < 1) { |
| 289 | if (isLayer) { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 290 | clipFlags &= ~CLIP_TO_BOUNDS; // bounds clipping done by layer |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 291 | } |
| 292 | if (CC_LIKELY(isLayer || !properties.getHasOverlappingRendering())) { |
| 293 | *alphaMultiplier = properties.getAlpha(); |
| 294 | } else { |
| 295 | // savelayer needed to create an offscreen buffer |
| 296 | Rect layerBounds(0, 0, properties.getWidth(), properties.getHeight()); |
| 297 | if (clipFlags) { |
| 298 | properties.getClippingRectForFlags(clipFlags, &layerBounds); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 299 | clipFlags = 0; // all clipping done by savelayer |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 300 | } |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 301 | SkRect bounds = SkRect::MakeLTRB(layerBounds.left, layerBounds.top, layerBounds.right, |
| 302 | layerBounds.bottom); |
| 303 | canvas->saveLayerAlpha(&bounds, (int)(properties.getAlpha() * 255)); |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | if (CC_UNLIKELY(ATRACE_ENABLED() && properties.promotedToLayer())) { |
| 307 | // pretend alpha always causes savelayer to warn about |
| 308 | // performance problem affecting old versions |
| 309 | ATRACE_FORMAT("alpha caused saveLayer %dx%d", properties.getWidth(), |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 310 | properties.getHeight()); |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 311 | } |
| 312 | } |
| 313 | |
| 314 | const SkRect* pendingClip = nullptr; |
| 315 | SkRect clipRect; |
| 316 | |
| 317 | if (clipFlags) { |
| 318 | Rect tmpRect; |
| 319 | properties.getClippingRectForFlags(clipFlags, &tmpRect); |
| 320 | clipRect = tmpRect.toSkRect(); |
| 321 | pendingClip = &clipRect; |
| 322 | } |
| 323 | |
| 324 | if (properties.getRevealClip().willClip()) { |
Mike Reed | 6c67f1d | 2016-12-14 10:29:54 -0500 | [diff] [blame] | 325 | canvas->clipPath(*properties.getRevealClip().getPath(), SkClipOp::kIntersect, true); |
Stan Iliev | 021693b | 2016-10-17 16:26:15 -0400 | [diff] [blame] | 326 | } else if (properties.getOutline().willClip()) { |
| 327 | clipOutline(properties.getOutline(), canvas, pendingClip); |
| 328 | pendingClip = nullptr; |
| 329 | } |
| 330 | |
| 331 | if (pendingClip) { |
| 332 | canvas->clipRect(*pendingClip); |
| 333 | } |
| 334 | } |
| 335 | |
Chris Blume | 7b8a808 | 2018-11-30 15:51:58 -0800 | [diff] [blame] | 336 | } // namespace skiapipeline |
| 337 | } // namespace uirenderer |
| 338 | } // namespace android |