Snapshot.cpp revision b29b16e5423fe7deab8ebf3da512c6d2192f19b5 
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
21namespace android {
22namespace uirenderer {
23
24///////////////////////////////////////////////////////////////////////////////
25// Constructors
26///////////////////////////////////////////////////////////////////////////////
27
28Snapshot::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 */
45Snapshot::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
75void Snapshot::clip(const Rect& localClip, SkClipOp op) {
76    flags |= Snapshot::kFlagClipSet;
77    mClipArea->clipRectWithTransform(localClip, transform, static_cast<SkRegion::Op>(op));
78}
79
80void Snapshot::clipPath(const SkPath& path, SkClipOp op) {
81    flags |= Snapshot::kFlagClipSet;
82    mClipArea->clipPathWithTransform(path, transform, static_cast<SkRegion::Op>(op));
83}
84
85void Snapshot::setClip(float left, float top, float right, float bottom) {
86    flags |= Snapshot::kFlagClipSet;
87    mClipArea->setClip(left, top, right, bottom);
88}
89
90bool Snapshot::hasPerspectiveTransform() const {
91    return transform->isPerspective();
92}
93
94const 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
104void 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
116void 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
161void Snapshot::setProjectionPathMask(const SkPath* path) {
162    projectionPathMask = path;
163}
164
165static Snapshot* getClipRoot(Snapshot* target) {
166    while (target->previous && target->previous->previous) {
167        target = target->previous;
168    }
169    return target;
170}
171
172const 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
184void 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
196void 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