1 /*
2 * Copyright (C) 2012 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 "Snapshot.h"
18
19 #include "hwui/Canvas.h"
20
21 namespace android {
22 namespace uirenderer {
23
24 ///////////////////////////////////////////////////////////////////////////////
25 // Constructors
26 ///////////////////////////////////////////////////////////////////////////////
27
Snapshot()28 Snapshot::Snapshot()
29 : flags(0)
30 , previous(nullptr)
31 , layer(nullptr)
32 , fbo(0)
33 , alpha(1.0f)
34 , roundRectClipState(nullptr)
35 , projectionPathMask(nullptr)
36 , mClipArea(&mClipAreaRoot) {
37 transform = &mTransformRoot;
38 mRelativeLightCenter.x = mRelativeLightCenter.y = mRelativeLightCenter.z = 0;
39 }
40
41 /**
42 * Copies the specified snapshot/ The specified snapshot is stored as
43 * the previous snapshot.
44 */
Snapshot(Snapshot * s,int saveFlags)45 Snapshot::Snapshot(Snapshot* s, int saveFlags)
46 : flags(0)
47 , previous(s)
48 , layer(s->layer)
49 , fbo(s->fbo)
50 , alpha(s->alpha)
51 , roundRectClipState(s->roundRectClipState)
52 , projectionPathMask(s->projectionPathMask)
53 , mClipArea(nullptr)
54 , mViewportData(s->mViewportData)
55 , mRelativeLightCenter(s->mRelativeLightCenter) {
56 if (saveFlags & SaveFlags::Matrix) {
57 mTransformRoot = *s->transform;
58 transform = &mTransformRoot;
59 } else {
60 transform = s->transform;
61 }
62
63 if (saveFlags & SaveFlags::Clip) {
64 mClipAreaRoot = s->getClipArea();
65 mClipArea = &mClipAreaRoot;
66 } else {
67 mClipArea = s->mClipArea;
68 }
69 }
70
71 ///////////////////////////////////////////////////////////////////////////////
72 // Clipping
73 ///////////////////////////////////////////////////////////////////////////////
74
clip(const Rect & localClip,SkClipOp op)75 void Snapshot::clip(const Rect& localClip, SkClipOp op) {
76 flags |= Snapshot::kFlagClipSet;
77 mClipArea->clipRectWithTransform(localClip, transform, static_cast<SkRegion::Op>(op));
78 }
79
clipPath(const SkPath & path,SkClipOp op)80 void Snapshot::clipPath(const SkPath& path, SkClipOp op) {
81 flags |= Snapshot::kFlagClipSet;
82 mClipArea->clipPathWithTransform(path, transform, static_cast<SkRegion::Op>(op));
83 }
84
setClip(float left,float top,float right,float bottom)85 void Snapshot::setClip(float left, float top, float right, float bottom) {
86 flags |= Snapshot::kFlagClipSet;
87 mClipArea->setClip(left, top, right, bottom);
88 }
89
hasPerspectiveTransform() const90 bool Snapshot::hasPerspectiveTransform() const {
91 return transform->isPerspective();
92 }
93
getLocalClip()94 const Rect& Snapshot::getLocalClip() {
95 mat4 inverse;
96 inverse.loadInverse(*transform);
97
98 mLocalClip.set(mClipArea->getClipRect());
99 inverse.mapRect(mLocalClip);
100
101 return mLocalClip;
102 }
103
resetClip(float left,float top,float right,float bottom)104 void Snapshot::resetClip(float left, float top, float right, float bottom) {
105 // TODO: This is incorrect, when we start rendering into a new layer,
106 // we may have to modify the previous snapshot's clip rect and clip
107 // region if the previous restore() call did not restore the clip
108 mClipArea = &mClipAreaRoot;
109 setClip(left, top, right, bottom);
110 }
111
112 ///////////////////////////////////////////////////////////////////////////////
113 // Clipping round rect
114 ///////////////////////////////////////////////////////////////////////////////
115
setClippingRoundRect(LinearAllocator & allocator,const Rect & bounds,float radius,bool highPriority)116 void Snapshot::setClippingRoundRect(LinearAllocator& allocator, const Rect& bounds,
117 float radius, bool highPriority) {
118 if (bounds.isEmpty()) {
119 mClipArea->setEmpty();
120 return;
121 }
122
123 if (roundRectClipState && roundRectClipState->highPriority) {
124 // ignore, don't replace, already have a high priority clip
125 return;
126 }
127
128 RoundRectClipState* state = new (allocator) RoundRectClipState;
129
130 state->highPriority = highPriority;
131
132 // store the inverse drawing matrix
133 Matrix4 roundRectDrawingMatrix = getOrthoMatrix();
134 roundRectDrawingMatrix.multiply(*transform);
135 state->matrix.loadInverse(roundRectDrawingMatrix);
136
137 // compute area under rounded corners - only draws overlapping these rects need to be clipped
138 for (int i = 0 ; i < 4; i++) {
139 state->dangerRects[i] = bounds;
140 }
141 state->dangerRects[0].bottom = state->dangerRects[1].bottom = bounds.top + radius;
142 state->dangerRects[0].right = state->dangerRects[2].right = bounds.left + radius;
143 state->dangerRects[1].left = state->dangerRects[3].left = bounds.right - radius;
144 state->dangerRects[2].top = state->dangerRects[3].top = bounds.bottom - radius;
145 for (int i = 0; i < 4; i++) {
146 transform->mapRect(state->dangerRects[i]);
147
148 // round danger rects out as though they are AA geometry (since they essentially are)
149 state->dangerRects[i].snapGeometryToPixelBoundaries(true);
150 }
151
152 // store RR area
153 state->innerRect = bounds;
154 state->innerRect.inset(radius);
155 state->radius = radius;
156
157 // store as immutable so, for this frame, pointer uniquely identifies this bundle of shader info
158 roundRectClipState = state;
159 }
160
setProjectionPathMask(const SkPath * path)161 void Snapshot::setProjectionPathMask(const SkPath* path) {
162 projectionPathMask = path;
163 }
164
getClipRoot(Snapshot * target)165 static Snapshot* getClipRoot(Snapshot* target) {
166 while (target->previous && target->previous->previous) {
167 target = target->previous;
168 }
169 return target;
170 }
171
serializeIntersectedClip(LinearAllocator & allocator,const ClipBase * recordedClip,const Matrix4 & recordedClipTransform)172 const ClipBase* Snapshot::serializeIntersectedClip(LinearAllocator& allocator,
173 const ClipBase* recordedClip, const Matrix4& recordedClipTransform) {
174 auto target = this;
175 if (CC_UNLIKELY(recordedClip && recordedClip->intersectWithRoot)) {
176 // Clip must be intersected with root, instead of current clip.
177 target = getClipRoot(this);
178 }
179
180 return target->mClipArea->serializeIntersectedClip(allocator,
181 recordedClip, recordedClipTransform);
182 }
183
applyClip(const ClipBase * recordedClip,const Matrix4 & transform)184 void Snapshot::applyClip(const ClipBase* recordedClip, const Matrix4& transform) {
185 if (CC_UNLIKELY(recordedClip && recordedClip->intersectWithRoot)) {
186 // current clip is being replaced, but must intersect with clip root
187 *mClipArea = *(getClipRoot(this)->mClipArea);
188 }
189 mClipArea->applyClip(recordedClip, transform);
190 }
191
192 ///////////////////////////////////////////////////////////////////////////////
193 // Queries
194 ///////////////////////////////////////////////////////////////////////////////
195
dump() const196 void Snapshot::dump() const {
197 ALOGD("Snapshot %p, flags %x, prev %p, height %d, hasComplexClip %d",
198 this, flags, previous, getViewportHeight(), !mClipArea->isSimple());
199 const Rect& clipRect(mClipArea->getClipRect());
200 ALOGD(" ClipRect %.1f %.1f %.1f %.1f, clip simple %d",
201 clipRect.left, clipRect.top, clipRect.right, clipRect.bottom, mClipArea->isSimple());
202
203 ALOGD(" Transform (at %p):", transform);
204 transform->dump();
205 }
206
207 }; // namespace uirenderer
208 }; // namespace android
209