blob: 2c23864317a4a540e152757871c5ae75f2ce88c8 [file] [log] [blame]
John Reck113e0822014-03-18 09:22:59 -07001/*
2 * Copyright (C) 2014 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
John Reck113e0822014-03-18 09:22:59 -070017#include "RenderNode.h"
18
Derek Sollenberger579317d42017-08-29 16:33:49 -040019#include <SkPathOps.h>
Robert Phillips74fe4712023-09-06 15:32:34 -040020#include <gui/TraceUtils.h>
21#include <ui/FatVector.h>
22
John Reck77c40102015-10-26 15:49:47 -070023#include <algorithm>
John Reckf96b2842018-11-29 09:44:10 -080024#include <atomic>
John Reck77c40102015-10-26 15:49:47 -070025#include <sstream>
26#include <string>
Robert Phillips74fe4712023-09-06 15:32:34 -040027
Jerome Gaillarddd37c982024-04-08 15:02:33 +010028#include "DamageAccumulator.h"
29#include "Debug.h"
30#include "Properties.h"
31#include "TreeInfo.h"
32#include "VectorDrawable.h"
33#include "private/hwui/WebViewFunctor.h"
34#include "renderthread/CanvasContext.h"
35
Robert Phillips74fe4712023-09-06 15:32:34 -040036#ifdef __ANDROID__
37#include "include/gpu/ganesh/SkImageGanesh.h"
38#endif
Tyler Freeman33567742023-10-31 01:55:51 +000039#include "utils/ForceDark.h"
Robert Phillips74fe4712023-09-06 15:32:34 -040040#include "utils/MathUtils.h"
41#include "utils/StringUtils.h"
John Reck77c40102015-10-26 15:49:47 -070042
John Reck113e0822014-03-18 09:22:59 -070043namespace android {
44namespace uirenderer {
45
John Reck2de950d2017-01-25 10:58:30 -080046// Used for tree mutations that are purely destructive.
47// Generic tree mutations should use MarkAndSweepObserver instead
48class ImmediateRemoved : public TreeObserver {
49public:
50 explicit ImmediateRemoved(TreeInfo* info) : mTreeInfo(info) {}
51
John Reck1bcacfd2017-11-03 10:12:19 -070052 void onMaybeRemovedFromTree(RenderNode* node) override { node->onRemovedFromTree(mTreeInfo); }
John Reck2de950d2017-01-25 10:58:30 -080053
54private:
55 TreeInfo* mTreeInfo;
56};
57
John Reckf96b2842018-11-29 09:44:10 -080058static int64_t generateId() {
59 static std::atomic<int64_t> sNextId{1};
60 return sNextId++;
61}
62
John Reck8de65a82014-04-09 15:23:38 -070063RenderNode::RenderNode()
John Reckf96b2842018-11-29 09:44:10 -080064 : mUniqueId(generateId())
65 , mDirtyPropertyFields(0)
Chris Craik003cc3d2015-10-16 10:24:55 -070066 , mNeedsDisplayListSync(false)
67 , mDisplayList(nullptr)
68 , mStagingDisplayList(nullptr)
John Reck68bfe0a2014-06-24 15:34:58 -070069 , mAnimatorManager(*this)
John Reck1bcacfd2017-11-03 10:12:19 -070070 , mParentCount(0) {}
John Reck113e0822014-03-18 09:22:59 -070071
72RenderNode::~RenderNode() {
John Reck2de950d2017-01-25 10:58:30 -080073 ImmediateRemoved observer(nullptr);
74 deleteDisplayList(observer);
Derek Sollenberger0df62092016-09-27 16:04:42 -040075 LOG_ALWAYS_FATAL_IF(hasLayer(), "layer missed detachment!");
John Reck113e0822014-03-18 09:22:59 -070076}
77
John Reckbe671952021-01-13 22:39:32 -050078void RenderNode::setStagingDisplayList(DisplayList&& newData) {
79 mValid = newData.isValid();
Chris Craik003cc3d2015-10-16 10:24:55 -070080 mNeedsDisplayListSync = true;
John Reckbe671952021-01-13 22:39:32 -050081 mStagingDisplayList = std::move(newData);
John Reck113e0822014-03-18 09:22:59 -070082}
83
John Reckdc1a6962021-01-12 13:56:07 -050084void RenderNode::discardStagingDisplayList() {
John Reckbe671952021-01-13 22:39:32 -050085 setStagingDisplayList(DisplayList());
John Reckdc1a6962021-01-12 13:56:07 -050086}
87
John Reck113e0822014-03-18 09:22:59 -070088/**
89 * This function is a simplified version of replay(), where we simply retrieve and log the
90 * display list. This function should remain in sync with the replay() function.
91 */
sergeyvc3849aa2016-08-08 13:22:06 -070092void RenderNode::output() {
93 LogcatStream strout;
94 strout << "Root";
95 output(strout, 0);
96}
97
98void RenderNode::output(std::ostream& output, uint32_t level) {
99 output << " (" << getName() << " " << this
John Reck1bcacfd2017-11-03 10:12:19 -0700100 << (MathUtils::isZero(properties().getAlpha()) ? ", zero alpha" : "")
101 << (properties().hasShadow() ? ", casting shadow" : "")
102 << (isRenderable() ? "" : ", empty")
103 << (properties().getProjectBackwards() ? ", projected" : "")
104 << (hasLayer() ? ", on HW Layer" : "") << ")" << std::endl;
sergeyvc3849aa2016-08-08 13:22:06 -0700105
106 properties().debugOutputProperties(output, level + 1);
Chris Craik91eff222016-02-22 13:39:33 -0800107
John Reckbe671952021-01-13 22:39:32 -0500108 mDisplayList.output(output, level);
sergeyvc3849aa2016-08-08 13:22:06 -0700109 output << std::string(level * 2, ' ') << "/RenderNode(" << getName() << " " << this << ")";
110 output << std::endl;
Chris Craik91eff222016-02-22 13:39:33 -0800111}
John Reck113e0822014-03-18 09:22:59 -0700112
John Reck07f3d912023-08-17 12:46:44 -0400113void RenderNode::visit(std::function<void(const RenderNode&)> func) const {
114 func(*this);
115 if (mDisplayList) {
116 mDisplayList.visit(func);
117 }
118}
119
John Reck183e1382019-10-09 13:41:18 -0700120int RenderNode::getUsageSize() {
John Reckfe5e7b72014-05-23 17:42:28 -0700121 int size = sizeof(RenderNode);
John Reckbe671952021-01-13 22:39:32 -0500122 size += mStagingDisplayList.getUsedSize();
123 size += mDisplayList.getUsedSize();
John Reckfe5e7b72014-05-23 17:42:28 -0700124 return size;
125}
126
John Reck183e1382019-10-09 13:41:18 -0700127int RenderNode::getAllocatedSize() {
128 int size = sizeof(RenderNode);
John Reckbe671952021-01-13 22:39:32 -0500129 size += mStagingDisplayList.getAllocatedSize();
130 size += mDisplayList.getAllocatedSize();
John Reck183e1382019-10-09 13:41:18 -0700131 return size;
132}
133
134
John Reckf4198b72014-04-09 17:00:04 -0700135void RenderNode::prepareTree(TreeInfo& info) {
136 ATRACE_CALL();
Chris Craik69e5adf2014-08-14 13:34:01 -0700137 LOG_ALWAYS_FATAL_IF(!info.damageAccumulator, "DamageAccumulator missing");
John Reck2de950d2017-01-25 10:58:30 -0800138 MarkAndSweepRemoved observer(&info);
John Reckf4198b72014-04-09 17:00:04 -0700139
John Reck1423e132018-09-21 14:30:19 -0700140 const int before = info.disableForceDark;
John Reck1072fff2018-04-12 15:20:09 -0700141 prepareTreeImpl(observer, info, false);
John Reck1423e132018-09-21 14:30:19 -0700142 LOG_ALWAYS_FATAL_IF(before != info.disableForceDark, "Mis-matched force dark");
John Reckf4198b72014-04-09 17:00:04 -0700143}
144
John Reck68bfe0a2014-06-24 15:34:58 -0700145void RenderNode::addAnimator(const sp<BaseRenderNodeAnimator>& animator) {
146 mAnimatorManager.addAnimator(animator);
147}
148
Doris Liu8b083202016-02-19 21:46:06 +0000149void RenderNode::removeAnimator(const sp<BaseRenderNodeAnimator>& animator) {
150 mAnimatorManager.removeAnimator(animator);
151}
152
John Recke4267ea2014-06-03 15:53:15 -0700153void RenderNode::damageSelf(TreeInfo& info) {
John Reckce9f3082014-06-17 16:18:09 -0700154 if (isRenderable()) {
John Reckf1aa7909e2019-03-07 17:01:08 -0800155 mDamageGenerationId = info.damageGenerationId;
John Reck293e8682014-06-17 10:34:02 -0700156 if (properties().getClipDamageToBounds()) {
John Recka447d292014-06-11 18:39:44 -0700157 info.damageAccumulator->dirty(0, 0, properties().getWidth(), properties().getHeight());
158 } else {
159 // Hope this is big enough?
160 // TODO: Get this from the display list ops or something
John Reckc12882392015-08-12 13:39:11 -0700161 info.damageAccumulator->dirty(DIRTY_MIN, DIRTY_MIN, DIRTY_MAX, DIRTY_MAX);
John Recka447d292014-06-11 18:39:44 -0700162 }
Ady Abrahamcab4afe2023-05-09 11:25:22 -0700163 if (!mIsTextureView) {
164 info.out.solelyTextureViewUpdates = false;
165 }
John Recke4267ea2014-06-03 15:53:15 -0700166 }
167}
168
John Recka7c2ea22014-08-08 13:21:00 -0700169void RenderNode::prepareLayer(TreeInfo& info, uint32_t dirtyMask) {
Chris Craik856f0cc2015-04-21 15:13:29 -0700170 LayerType layerType = properties().effectiveLayerType();
Chris Craik182952f2015-03-09 14:17:29 -0700171 if (CC_UNLIKELY(layerType == LayerType::RenderLayer)) {
John Recka7c2ea22014-08-08 13:21:00 -0700172 // Damage applied so far needs to affect our parent, but does not require
173 // the layer to be updated. So we pop/push here to clear out the current
174 // damage and get a clean state for display list or children updates to
175 // affect, which will require the layer to be updated
176 info.damageAccumulator->popTransform();
177 info.damageAccumulator->pushTransform(this);
178 if (dirtyMask & DISPLAY_LIST) {
179 damageSelf(info);
180 }
John Reck25fbb3f2014-06-12 13:46:45 -0700181 }
182}
183
184void RenderNode::pushLayerUpdate(TreeInfo& info) {
Chris Craik856f0cc2015-04-21 15:13:29 -0700185 LayerType layerType = properties().effectiveLayerType();
John Reck25fbb3f2014-06-12 13:46:45 -0700186 // If we are not a layer OR we cannot be rendered (eg, view was detached)
187 // we need to destroy any Layers we may have had previously
John Reck1bcacfd2017-11-03 10:12:19 -0700188 if (CC_LIKELY(layerType != LayerType::RenderLayer) || CC_UNLIKELY(!isRenderable()) ||
189 CC_UNLIKELY(properties().getWidth() == 0) || CC_UNLIKELY(properties().getHeight() == 0) ||
190 CC_UNLIKELY(!properties().fitsOnLayer())) {
Derek Sollenberger0df62092016-09-27 16:04:42 -0400191 if (CC_UNLIKELY(hasLayer())) {
Derek Sollenberger28a4d992018-09-20 13:37:24 -0400192 this->setLayerSurface(nullptr);
John Reck25fbb3f2014-06-12 13:46:45 -0700193 }
194 return;
195 }
196
Stan Iliev216b1572018-03-26 14:29:50 -0400197 if (info.canvasContext.createOrUpdateLayer(this, *info.damageAccumulator, info.errorHandler)) {
Chris Craik9fded232015-11-11 16:42:34 -0800198 damageSelf(info);
Chris Craik69e5adf2014-08-14 13:34:01 -0700199 }
200
Derek Sollenberger0df62092016-09-27 16:04:42 -0400201 if (!hasLayer()) {
John Reckc25e5062014-06-18 14:21:29 -0700202 return;
203 }
204
Derek Sollenberger6a21ca52016-09-28 13:39:55 -0400205 SkRect dirty;
206 info.damageAccumulator->peekAtDirty(&dirty);
Chris Craik0b7e8242015-10-28 16:50:44 -0700207 info.layerUpdateQueue->enqueueLayerWithDamage(this, dirty);
Nader Jawad197743f2021-04-19 19:45:13 -0700208 if (!dirty.isEmpty()) {
209 mStretchMask.markDirty();
210 }
John Reck998a6d82014-08-28 15:35:53 -0700211
Chris Craike2e53a72015-10-28 15:55:40 -0700212 // There might be prefetched layers that need to be accounted for.
213 // That might be us, so tell CanvasContext that this layer is in the
214 // tree and should not be destroyed.
215 info.canvasContext.markLayerInUse(this);
John Reck25fbb3f2014-06-12 13:46:45 -0700216}
217
Chris Craika766cb22015-06-08 16:49:43 -0700218/**
219 * Traverse down the the draw tree to prepare for a frame.
220 *
221 * MODE_FULL = UI Thread-driven (thus properties must be synced), otherwise RT driven
222 *
223 * While traversing down the tree, functorsNeedLayer flag is set to true if anything that uses the
224 * stencil buffer may be needed. Views that use a functor to draw will be forced onto a layer.
225 */
John Reck2de950d2017-01-25 10:58:30 -0800226void RenderNode::prepareTreeImpl(TreeObserver& observer, TreeInfo& info, bool functorsNeedLayer) {
qiubowen13d879b2024-01-22 19:46:22 +0800227 if (mDamageGenerationId == info.damageGenerationId && mDamageGenerationId != 0) {
John Reckf1aa7909e2019-03-07 17:01:08 -0800228 // We hit the same node a second time in the same tree. We don't know the minimal
229 // damage rect anymore, so just push the biggest we can onto our parent's transform
230 // We push directly onto parent in case we are clipped to bounds but have moved position.
231 info.damageAccumulator->dirty(DIRTY_MIN, DIRTY_MIN, DIRTY_MAX, DIRTY_MAX);
232 }
John Recka447d292014-06-11 18:39:44 -0700233 info.damageAccumulator->pushTransform(this);
John Reckf47a5942014-06-30 16:20:04 -0700234
John Reckdcba6722014-07-08 13:59:49 -0700235 if (info.mode == TreeInfo::MODE_FULL) {
John Reck25fbb3f2014-06-12 13:46:45 -0700236 pushStagingPropertiesChanges(info);
John Recke45b1fd2014-04-15 09:50:16 -0700237 }
John Reck1423e132018-09-21 14:30:19 -0700238
239 if (!mProperties.getAllowForceDark()) {
240 info.disableForceDark++;
241 }
John Reck5d53a752021-02-08 19:22:59 -0500242 if (!mProperties.layerProperties().getStretchEffect().isEmpty()) {
243 info.stretchEffectCount++;
244 }
John Reck1423e132018-09-21 14:30:19 -0700245
John Reck9eb9f6f2014-08-21 11:23:05 -0700246 uint32_t animatorDirtyMask = 0;
247 if (CC_LIKELY(info.runAnimations)) {
248 animatorDirtyMask = mAnimatorManager.animate(info);
249 }
Chris Craika766cb22015-06-08 16:49:43 -0700250
John Reck3f725f02015-06-16 10:29:31 -0700251 bool willHaveFunctor = false;
Chris Craik003cc3d2015-10-16 10:24:55 -0700252 if (info.mode == TreeInfo::MODE_FULL && mStagingDisplayList) {
John Reckbe671952021-01-13 22:39:32 -0500253 willHaveFunctor = mStagingDisplayList.hasFunctor();
Chris Craik003cc3d2015-10-16 10:24:55 -0700254 } else if (mDisplayList) {
John Reckbe671952021-01-13 22:39:32 -0500255 willHaveFunctor = mDisplayList.hasFunctor();
John Reck3f725f02015-06-16 10:29:31 -0700256 }
John Reck1bcacfd2017-11-03 10:12:19 -0700257 bool childFunctorsNeedLayer =
258 mProperties.prepareForFunctorPresence(willHaveFunctor, functorsNeedLayer);
Chris Craika766cb22015-06-08 16:49:43 -0700259
John Reckf6481082016-02-02 15:18:23 -0800260 if (CC_UNLIKELY(mPositionListener.get())) {
261 mPositionListener->onPositionUpdated(*this, info);
262 }
263
John Recka7c2ea22014-08-08 13:21:00 -0700264 prepareLayer(info, animatorDirtyMask);
John Reckdcba6722014-07-08 13:59:49 -0700265 if (info.mode == TreeInfo::MODE_FULL) {
John Reck2de950d2017-01-25 10:58:30 -0800266 pushStagingDisplayListChanges(observer, info);
John Reck25fbb3f2014-06-12 13:46:45 -0700267 }
John Reck25fbb3f2014-06-12 13:46:45 -0700268
Dongya Jiange2b99382022-02-28 21:35:57 +0800269 // always damageSelf when filtering backdrop content, or else the BackdropFilterDrawable will
270 // get a wrong snapshot of previous content.
271 if (mProperties.layerProperties().getBackdropImageFilter()) {
272 damageSelf(info);
273 }
274
Doris Liu07c056d2016-06-13 12:52:44 -0700275 if (mDisplayList) {
John Reckbe671952021-01-13 22:39:32 -0500276 info.out.hasFunctors |= mDisplayList.hasFunctor();
Nader Jawad2dc632a2021-03-29 18:51:29 -0700277 mHasHolePunches = mDisplayList.hasHolePunches();
John Reckbe671952021-01-13 22:39:32 -0500278 bool isDirty = mDisplayList.prepareListAndChildren(
John Reck1bcacfd2017-11-03 10:12:19 -0700279 observer, info, childFunctorsNeedLayer,
Nader Jawad2dc632a2021-03-29 18:51:29 -0700280 [this](RenderNode* child, TreeObserver& observer, TreeInfo& info,
281 bool functorsNeedLayer) {
John Reck1bcacfd2017-11-03 10:12:19 -0700282 child->prepareTreeImpl(observer, info, functorsNeedLayer);
Nader Jawad2dc632a2021-03-29 18:51:29 -0700283 mHasHolePunches |= child->hasHolePunches();
John Reck1bcacfd2017-11-03 10:12:19 -0700284 });
Derek Sollenberger0df62092016-09-27 16:04:42 -0400285 if (isDirty) {
286 damageSelf(info);
Doris Liu718cd3e2016-05-17 16:50:31 -0700287 }
Nader Jawad2dc632a2021-03-29 18:51:29 -0700288 } else {
289 mHasHolePunches = false;
Doris Liu718cd3e2016-05-17 16:50:31 -0700290 }
Doris Liub51b2862016-08-01 19:56:47 -0700291 pushLayerUpdate(info);
Doris Liu718cd3e2016-05-17 16:50:31 -0700292
John Reck1423e132018-09-21 14:30:19 -0700293 if (!mProperties.getAllowForceDark()) {
294 info.disableForceDark--;
295 }
John Reck5d53a752021-02-08 19:22:59 -0500296 if (!mProperties.layerProperties().getStretchEffect().isEmpty()) {
297 info.stretchEffectCount--;
298 }
John Recka447d292014-06-11 18:39:44 -0700299 info.damageAccumulator->popTransform();
John Reckf4198b72014-04-09 17:00:04 -0700300}
301
Chris Craikb565df12015-10-05 13:00:52 -0700302void RenderNode::syncProperties() {
303 mProperties = mStagingProperties;
304}
305
John Reck25fbb3f2014-06-12 13:46:45 -0700306void RenderNode::pushStagingPropertiesChanges(TreeInfo& info) {
John Reck097e1d32019-06-12 15:01:51 -0700307 if (mPositionListenerDirty) {
308 mPositionListener = std::move(mStagingPositionListener);
309 mStagingPositionListener = nullptr;
310 mPositionListenerDirty = false;
311 }
312
John Reckff941dc2014-05-14 16:34:14 -0700313 // Push the animators first so that setupStartValueIfNecessary() is called
314 // before properties() is trampled by stagingProperties(), as they are
315 // required by some animators.
John Reck9eb9f6f2014-08-21 11:23:05 -0700316 if (CC_LIKELY(info.runAnimations)) {
John Reck119907c2014-08-14 09:02:01 -0700317 mAnimatorManager.pushStaging();
John Reck9eb9f6f2014-08-21 11:23:05 -0700318 }
John Reckff941dc2014-05-14 16:34:14 -0700319 if (mDirtyPropertyFields) {
320 mDirtyPropertyFields = 0;
John Recke4267ea2014-06-03 15:53:15 -0700321 damageSelf(info);
John Recka447d292014-06-11 18:39:44 -0700322 info.damageAccumulator->popTransform();
Chris Craikb565df12015-10-05 13:00:52 -0700323 syncProperties();
Nader Jawad197743f2021-04-19 19:45:13 -0700324
Nader Jawad6aff4812021-06-09 10:14:43 -0700325 auto& layerProperties = mProperties.layerProperties();
326 const StretchEffect& stagingStretch = layerProperties.getStretchEffect();
Nader Jawad197743f2021-04-19 19:45:13 -0700327 if (stagingStretch.isEmpty()) {
328 mStretchMask.clear();
329 }
Nader Jawad6aff4812021-06-09 10:14:43 -0700330
331 if (layerProperties.getImageFilter() == nullptr) {
332 mSnapshotResult.snapshot = nullptr;
333 mTargetImageFilter = nullptr;
334 }
335
John Recke4267ea2014-06-03 15:53:15 -0700336 // We could try to be clever and only re-damage if the matrix changed.
337 // However, we don't need to worry about that. The cost of over-damaging
338 // here is only going to be a single additional map rect of this node
339 // plus a rect join(). The parent's transform (and up) will only be
340 // performed once.
John Recka447d292014-06-11 18:39:44 -0700341 info.damageAccumulator->pushTransform(this);
John Recke4267ea2014-06-03 15:53:15 -0700342 damageSelf(info);
John Reckff941dc2014-05-14 16:34:14 -0700343 }
John Reck25fbb3f2014-06-12 13:46:45 -0700344}
345
Nader Jawad6aff4812021-06-09 10:14:43 -0700346std::optional<RenderNode::SnapshotResult> RenderNode::updateSnapshotIfRequired(
347 GrRecordingContext* context,
348 const SkImageFilter* imageFilter,
349 const SkIRect& clipBounds
350) {
351 auto* layerSurface = getLayerSurface();
352 if (layerSurface == nullptr) {
353 return std::nullopt;
354 }
355
356 sk_sp<SkImage> snapshot = layerSurface->makeImageSnapshot();
357 const auto subset = SkIRect::MakeWH(properties().getWidth(),
358 properties().getHeight());
Nader Jawadf49068f2021-09-08 22:17:15 -0700359 uint32_t layerSurfaceGenerationId = layerSurface->generationID();
Nader Jawad6aff4812021-06-09 10:14:43 -0700360 // If we don't have an ImageFilter just return the snapshot
361 if (imageFilter == nullptr) {
362 mSnapshotResult.snapshot = snapshot;
363 mSnapshotResult.outSubset = subset;
364 mSnapshotResult.outOffset = SkIPoint::Make(0.0f, 0.0f);
365 mImageFilterClipBounds = clipBounds;
366 mTargetImageFilter = nullptr;
Nader Jawadf49068f2021-09-08 22:17:15 -0700367 mTargetImageFilterLayerSurfaceGenerationId = 0;
368 } else if (mSnapshotResult.snapshot == nullptr || imageFilter != mTargetImageFilter.get() ||
369 mImageFilterClipBounds != clipBounds ||
370 mTargetImageFilterLayerSurfaceGenerationId != layerSurfaceGenerationId) {
Nader Jawad6aff4812021-06-09 10:14:43 -0700371 // Otherwise create a new snapshot with the given filter and snapshot
Robert Phillips74fe4712023-09-06 15:32:34 -0400372#ifdef __ANDROID__
373 if (context) {
374 mSnapshotResult.snapshot = SkImages::MakeWithFilter(
375 context, snapshot, imageFilter, subset, clipBounds, &mSnapshotResult.outSubset,
376 &mSnapshotResult.outOffset);
377 } else
378#endif
379 {
380 mSnapshotResult.snapshot = SkImages::MakeWithFilter(
381 snapshot, imageFilter, subset, clipBounds, &mSnapshotResult.outSubset,
382 &mSnapshotResult.outOffset);
383 }
Nader Jawad6aff4812021-06-09 10:14:43 -0700384 mTargetImageFilter = sk_ref_sp(imageFilter);
385 mImageFilterClipBounds = clipBounds;
Nader Jawadf49068f2021-09-08 22:17:15 -0700386 mTargetImageFilterLayerSurfaceGenerationId = layerSurfaceGenerationId;
Nader Jawad6aff4812021-06-09 10:14:43 -0700387 }
388
389 return mSnapshotResult;
390}
391
John Reck2de950d2017-01-25 10:58:30 -0800392void RenderNode::syncDisplayList(TreeObserver& observer, TreeInfo* info) {
Chris Craikb565df12015-10-05 13:00:52 -0700393 // Make sure we inc first so that we don't fluctuate between 0 and 1,
394 // which would thrash the layer cache
Chris Craik003cc3d2015-10-16 10:24:55 -0700395 if (mStagingDisplayList) {
John Reckbe671952021-01-13 22:39:32 -0500396 mStagingDisplayList.updateChildren([](RenderNode* child) { child->incParentRefCount(); });
Chris Craikb565df12015-10-05 13:00:52 -0700397 }
John Reck2de950d2017-01-25 10:58:30 -0800398 deleteDisplayList(observer, info);
John Reckbe671952021-01-13 22:39:32 -0500399 mDisplayList = std::move(mStagingDisplayList);
Chris Craik003cc3d2015-10-16 10:24:55 -0700400 if (mDisplayList) {
Tyler Freeman33567742023-10-31 01:55:51 +0000401 WebViewSyncData syncData{.applyForceDark = shouldEnableForceDark(info)};
John Reckbe671952021-01-13 22:39:32 -0500402 mDisplayList.syncContents(syncData);
John Reck3b4510cd2018-09-27 17:39:45 -0700403 handleForceDark(info);
404 }
405}
John Reckf3c724f2018-09-20 13:00:04 -0700406
Tyler Freeman3455a212024-09-03 18:01:08 +0000407inline bool RenderNode::isForceInvertDark(TreeInfo& info) {
408 return CC_UNLIKELY(
409 info.forceDarkType == android::uirenderer::ForceDarkType::FORCE_INVERT_COLOR_DARK);
410}
411
Tyler Freeman33567742023-10-31 01:55:51 +0000412inline bool RenderNode::shouldEnableForceDark(TreeInfo* info) {
413 return CC_UNLIKELY(
414 info &&
Tyler Freeman3455a212024-09-03 18:01:08 +0000415 (!info->disableForceDark || isForceInvertDark(*info)));
Tyler Freeman33567742023-10-31 01:55:51 +0000416}
417
Tyler Freeman3455a212024-09-03 18:01:08 +0000418
419
John Reck3b4510cd2018-09-27 17:39:45 -0700420void RenderNode::handleForceDark(android::uirenderer::TreeInfo *info) {
Tyler Freeman33567742023-10-31 01:55:51 +0000421 if (!shouldEnableForceDark(info)) {
John Reck3b4510cd2018-09-27 17:39:45 -0700422 return;
423 }
424 auto usage = usageHint();
John Reckbe671952021-01-13 22:39:32 -0500425 FatVector<RenderNode*, 6> children;
426 mDisplayList.updateChildren([&children](RenderNode* node) {
427 children.push_back(node);
428 });
429 if (mDisplayList.hasText()) {
Tyler Freeman3455a212024-09-03 18:01:08 +0000430 if (isForceInvertDark(*info) && mDisplayList.hasFill()) {
Tyler Freemane0faa692023-11-16 00:48:54 +0000431 // Handle a special case for custom views that draw both text and background in the
432 // same RenderNode, which would otherwise be altered to white-on-white text.
433 usage = UsageHint::Container;
434 } else {
435 usage = UsageHint::Foreground;
436 }
John Reck3b4510cd2018-09-27 17:39:45 -0700437 }
438 if (usage == UsageHint::Unknown) {
439 if (children.size() > 1) {
440 usage = UsageHint::Background;
441 } else if (children.size() == 1 &&
John Reckbe671952021-01-13 22:39:32 -0500442 children.front()->usageHint() !=
John Reck3b4510cd2018-09-27 17:39:45 -0700443 UsageHint::Background) {
444 usage = UsageHint::Background;
John Reck8f45d4a2018-08-15 10:17:12 -0700445 }
Chris Craikb565df12015-10-05 13:00:52 -0700446 }
John Reck3b4510cd2018-09-27 17:39:45 -0700447 if (children.size() > 1) {
448 // Crude overlap check
449 SkRect drawn = SkRect::MakeEmpty();
450 for (auto iter = children.rbegin(); iter != children.rend(); ++iter) {
John Reckbe671952021-01-13 22:39:32 -0500451 const auto& child = *iter;
John Reck3b4510cd2018-09-27 17:39:45 -0700452 // We use stagingProperties here because we haven't yet sync'd the children
453 SkRect bounds = SkRect::MakeXYWH(child->stagingProperties().getX(), child->stagingProperties().getY(),
454 child->stagingProperties().getWidth(), child->stagingProperties().getHeight());
455 if (bounds.contains(drawn)) {
456 // This contains everything drawn after it, so make it a background
457 child->setUsageHint(UsageHint::Background);
458 }
459 drawn.join(bounds);
460 }
461 }
Tyler Freemane0faa692023-11-16 00:48:54 +0000462
463 if (usage == UsageHint::Container) {
464 mDisplayList.applyColorTransform(ColorTransform::Invert);
465 } else {
466 mDisplayList.applyColorTransform(usage == UsageHint::Background ? ColorTransform::Dark
467 : ColorTransform::Light);
468 }
Chris Craikb565df12015-10-05 13:00:52 -0700469}
470
John Reck2de950d2017-01-25 10:58:30 -0800471void RenderNode::pushStagingDisplayListChanges(TreeObserver& observer, TreeInfo& info) {
Chris Craik003cc3d2015-10-16 10:24:55 -0700472 if (mNeedsDisplayListSync) {
473 mNeedsDisplayListSync = false;
John Reck5c9d7172014-10-22 11:32:27 -0700474 // Damage with the old display list first then the new one to catch any
475 // changes in isRenderable or, in the future, bounds
476 damageSelf(info);
John Reck2de950d2017-01-25 10:58:30 -0800477 syncDisplayList(observer, &info);
John Recke4267ea2014-06-03 15:53:15 -0700478 damageSelf(info);
John Reck8de65a82014-04-09 15:23:38 -0700479 }
John Reck8de65a82014-04-09 15:23:38 -0700480}
481
John Reck2de950d2017-01-25 10:58:30 -0800482void RenderNode::deleteDisplayList(TreeObserver& observer, TreeInfo* info) {
Chris Craik003cc3d2015-10-16 10:24:55 -0700483 if (mDisplayList) {
John Reckbe671952021-01-13 22:39:32 -0500484 mDisplayList.updateChildren(
John Reck1bcacfd2017-11-03 10:12:19 -0700485 [&observer, info](RenderNode* child) { child->decParentRefCount(observer, info); });
John Reckbe671952021-01-13 22:39:32 -0500486 mDisplayList.clear(this);
John Reckdcba6722014-07-08 13:59:49 -0700487 }
John Reckdcba6722014-07-08 13:59:49 -0700488}
489
John Reck2de950d2017-01-25 10:58:30 -0800490void RenderNode::destroyHardwareResources(TreeInfo* info) {
Derek Sollenberger0df62092016-09-27 16:04:42 -0400491 if (hasLayer()) {
Derek Sollenberger28a4d992018-09-20 13:37:24 -0400492 this->setLayerSurface(nullptr);
John Reckdcba6722014-07-08 13:59:49 -0700493 }
John Reckbe671952021-01-13 22:39:32 -0500494 discardStagingDisplayList();
John Reck3afd6372017-01-30 10:15:48 -0800495
496 ImmediateRemoved observer(info);
497 deleteDisplayList(observer, info);
John Reck2de950d2017-01-25 10:58:30 -0800498}
499
500void RenderNode::destroyLayers() {
501 if (hasLayer()) {
Derek Sollenberger28a4d992018-09-20 13:37:24 -0400502 this->setLayerSurface(nullptr);
John Reck2de950d2017-01-25 10:58:30 -0800503 }
Nader Jawadb502ad72021-06-17 14:10:04 -0700504
John Reck2de950d2017-01-25 10:58:30 -0800505 if (mDisplayList) {
John Reckbe671952021-01-13 22:39:32 -0500506 mDisplayList.updateChildren([](RenderNode* child) { child->destroyLayers(); });
John Reck2de950d2017-01-25 10:58:30 -0800507 }
508}
509
510void RenderNode::decParentRefCount(TreeObserver& observer, TreeInfo* info) {
511 LOG_ALWAYS_FATAL_IF(!mParentCount, "already 0!");
512 mParentCount--;
513 if (!mParentCount) {
514 observer.onMaybeRemovedFromTree(this);
515 if (CC_UNLIKELY(mPositionListener.get())) {
516 mPositionListener->onPositionLost(*this, info);
John Reckdcba6722014-07-08 13:59:49 -0700517 }
518 }
519}
520
John Reck2de950d2017-01-25 10:58:30 -0800521void RenderNode::onRemovedFromTree(TreeInfo* info) {
Huihong Luoec68b7c2021-06-25 21:54:16 -0700522 if (Properties::enableWebViewOverlays && mDisplayList) {
523 mDisplayList.onRemovedFromTree();
524 }
John Reck2de950d2017-01-25 10:58:30 -0800525 destroyHardwareResources(info);
526}
527
528void RenderNode::clearRoot() {
529 ImmediateRemoved observer(nullptr);
530 decParentRefCount(observer);
John Reckdcba6722014-07-08 13:59:49 -0700531}
532
John Reck113e0822014-03-18 09:22:59 -0700533/**
534 * Apply property-based transformations to input matrix
535 *
536 * If true3dTransform is set to true, the transform applied to the input matrix will use true 4x4
537 * matrix computation instead of the Skia 3x3 matrix + camera hackery.
538 */
Chris Craik69e5adf2014-08-14 13:34:01 -0700539void RenderNode::applyViewPropertyTransforms(mat4& matrix, bool true3dTransform) const {
John Reckd0a0b2a2014-03-20 16:28:56 -0700540 if (properties().getLeft() != 0 || properties().getTop() != 0) {
541 matrix.translate(properties().getLeft(), properties().getTop());
John Reck113e0822014-03-18 09:22:59 -0700542 }
John Reckd0a0b2a2014-03-20 16:28:56 -0700543 if (properties().getStaticMatrix()) {
544 mat4 stat(*properties().getStaticMatrix());
John Reck113e0822014-03-18 09:22:59 -0700545 matrix.multiply(stat);
John Reckd0a0b2a2014-03-20 16:28:56 -0700546 } else if (properties().getAnimationMatrix()) {
547 mat4 anim(*properties().getAnimationMatrix());
John Reck113e0822014-03-18 09:22:59 -0700548 matrix.multiply(anim);
549 }
Chris Craike0bb87d2014-04-22 17:55:41 -0700550
Chris Craikcc39e162014-04-25 18:34:11 -0700551 bool applyTranslationZ = true3dTransform && !MathUtils::isZero(properties().getZ());
Chris Craike0bb87d2014-04-22 17:55:41 -0700552 if (properties().hasTransformMatrix() || applyTranslationZ) {
John Reckf7483e32014-04-11 08:54:47 -0700553 if (properties().isTransformTranslateOnly()) {
John Reckd0a0b2a2014-03-20 16:28:56 -0700554 matrix.translate(properties().getTranslationX(), properties().getTranslationY(),
John Reck1bcacfd2017-11-03 10:12:19 -0700555 true3dTransform ? properties().getZ() : 0.0f);
John Reck113e0822014-03-18 09:22:59 -0700556 } else {
557 if (!true3dTransform) {
John Reckd0a0b2a2014-03-20 16:28:56 -0700558 matrix.multiply(*properties().getTransformMatrix());
John Reck113e0822014-03-18 09:22:59 -0700559 } else {
560 mat4 true3dMat;
John Reck1bcacfd2017-11-03 10:12:19 -0700561 true3dMat.loadTranslate(properties().getPivotX() + properties().getTranslationX(),
562 properties().getPivotY() + properties().getTranslationY(),
563 properties().getZ());
John Reckd0a0b2a2014-03-20 16:28:56 -0700564 true3dMat.rotate(properties().getRotationX(), 1, 0, 0);
565 true3dMat.rotate(properties().getRotationY(), 0, 1, 0);
566 true3dMat.rotate(properties().getRotation(), 0, 0, 1);
567 true3dMat.scale(properties().getScaleX(), properties().getScaleY(), 1);
568 true3dMat.translate(-properties().getPivotX(), -properties().getPivotY());
John Reck113e0822014-03-18 09:22:59 -0700569
570 matrix.multiply(true3dMat);
571 }
572 }
573 }
John Reck8ed00dc2021-05-10 13:09:27 -0400574
Nader Jawad93d6e242021-05-17 18:12:29 -0700575 if (Properties::getStretchEffectBehavior() == StretchEffectBehavior::UniformScale) {
John Reck8ed00dc2021-05-10 13:09:27 -0400576 const StretchEffect& stretch = properties().layerProperties().getStretchEffect();
577 if (!stretch.isEmpty()) {
578 matrix.multiply(
579 stretch.makeLinearStretch(properties().getWidth(), properties().getHeight()));
580 }
581 }
John Reck113e0822014-03-18 09:22:59 -0700582}
583
Derek Sollenberger579317d42017-08-29 16:33:49 -0400584const SkPath* RenderNode::getClippedOutline(const SkRect& clipRect) const {
585 const SkPath* outlinePath = properties().getOutline().getPath();
586 const uint32_t outlineID = outlinePath->getGenerationID();
587
588 if (outlineID != mClippedOutlineCache.outlineID || clipRect != mClippedOutlineCache.clipRect) {
589 // update the cache keys
590 mClippedOutlineCache.outlineID = outlineID;
591 mClippedOutlineCache.clipRect = clipRect;
592
593 // update the cache value by recomputing a new path
594 SkPath clipPath;
595 clipPath.addRect(clipRect);
596 Op(*outlinePath, clipPath, kIntersect_SkPathOp, &mClippedOutlineCache.clippedOutline);
Derek Sollenberger579317d42017-08-29 16:33:49 -0400597 }
598 return &mClippedOutlineCache.clippedOutline;
599}
600
John Reckf96b2842018-11-29 09:44:10 -0800601using StringBuffer = FatVector<char, 128>;
602
603template <typename... T>
John Reck7af5b2c2018-12-05 13:36:20 -0800604// TODO:__printflike(2, 3)
605// Doesn't work because the warning doesn't understand string_view and doesn't like that
606// it's not a C-style variadic function.
John Reckf96b2842018-11-29 09:44:10 -0800607static void format(StringBuffer& buffer, const std::string_view& format, T... args) {
608 buffer.resize(buffer.capacity());
609 while (1) {
610 int needed = snprintf(buffer.data(), buffer.size(),
611 format.data(), std::forward<T>(args)...);
612 if (needed < 0) {
613 buffer[0] = '\0';
614 buffer.resize(1);
615 return;
616 }
617 if (needed < buffer.size()) {
618 buffer.resize(needed + 1);
619 return;
620 }
John Reck7af5b2c2018-12-05 13:36:20 -0800621 // If we're doing a heap alloc anyway might as well give it some slop
622 buffer.resize(needed + 100);
John Reckf96b2842018-11-29 09:44:10 -0800623 }
624}
625
626void RenderNode::markDrawStart(SkCanvas& canvas) {
627 StringBuffer buffer;
John Reck7af5b2c2018-12-05 13:36:20 -0800628 format(buffer, "RenderNode(id=%" PRId64 ", name='%s')", uniqueId(), getName());
John Reckf96b2842018-11-29 09:44:10 -0800629 canvas.drawAnnotation(SkRect::MakeWH(getWidth(), getHeight()), buffer.data(), nullptr);
630}
631
632void RenderNode::markDrawEnd(SkCanvas& canvas) {
633 StringBuffer buffer;
John Reck7af5b2c2018-12-05 13:36:20 -0800634 format(buffer, "/RenderNode(id=%" PRId64 ", name='%s')", uniqueId(), getName());
John Reckf96b2842018-11-29 09:44:10 -0800635 canvas.drawAnnotation(SkRect::MakeWH(getWidth(), getHeight()), buffer.data(), nullptr);
636}
637
John Reck113e0822014-03-18 09:22:59 -0700638} /* namespace uirenderer */
639} /* namespace android */