Home | History | Annotate | Download | only in hwui 
      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 
     28 Snapshot::Snapshot()
     29         : flags(0)
     30         , previous(nullptr)
     31         , layer(nullptr)
     32         , fbo(0)
     33         , invisible(false)
     34         , empty(false)
     35         , alpha(1.0f)
     36         , roundRectClipState(nullptr)
     37         , projectionPathMask(nullptr)
     38         , mClipArea(&mClipAreaRoot) {
     39     transform = &mTransformRoot;
     40     region = nullptr;
     41 }
     42 
     43 /**
     44  * Copies the specified snapshot/ The specified snapshot is stored as
     45  * the previous snapshot.
     46  */
     47 Snapshot::Snapshot(Snapshot* s, int saveFlags)
     48         : flags(0)
     49         , previous(s)
     50         , layer(s->layer)
     51         , fbo(s->fbo)
     52         , invisible(s->invisible)
     53         , empty(false)
     54         , alpha(s->alpha)
     55         , roundRectClipState(s->roundRectClipState)
     56         , projectionPathMask(s->projectionPathMask)
     57         , mClipArea(nullptr)
     58         , mViewportData(s->mViewportData)
     59         , mRelativeLightCenter(s->mRelativeLightCenter) {
     60     if (saveFlags & SaveFlags::Matrix) {
     61         mTransformRoot = *s->transform;
     62         transform = &mTransformRoot;
     63     } else {
     64         transform = s->transform;
     65     }
     66 
     67     if (saveFlags & SaveFlags::Clip) {
     68         mClipAreaRoot = s->getClipArea();
     69         mClipArea = &mClipAreaRoot;
     70     } else {
     71         mClipArea = s->mClipArea;
     72     }
     73 
     74     if (s->flags & Snapshot::kFlagFboTarget) {
     75         flags |= Snapshot::kFlagFboTarget;
     76         region = s->region;
     77     } else {
     78         region = nullptr;
     79     }
     80 }
     81 
     82 ///////////////////////////////////////////////////////////////////////////////
     83 // Clipping
     84 ///////////////////////////////////////////////////////////////////////////////
     85 
     86 void Snapshot::clipRegionTransformed(const SkRegion& region, SkRegion::Op op) {
     87     flags |= Snapshot::kFlagClipSet;
     88     mClipArea->clipRegion(region, op);
     89 }
     90 
     91 void Snapshot::clip(const Rect& localClip, SkRegion::Op op) {
     92     flags |= Snapshot::kFlagClipSet;
     93     mClipArea->clipRectWithTransform(localClip, transform, op);
     94 }
     95 
     96 void Snapshot::clipPath(const SkPath& path, SkRegion::Op op) {
     97     flags |= Snapshot::kFlagClipSet;
     98     mClipArea->clipPathWithTransform(path, transform, op);
     99 }
    100 
    101 void Snapshot::setClip(float left, float top, float right, float bottom) {
    102     flags |= Snapshot::kFlagClipSet;
    103     mClipArea->setClip(left, top, right, bottom);
    104 }
    105 
    106 bool Snapshot::hasPerspectiveTransform() const {
    107     return transform->isPerspective();
    108 }
    109 
    110 const Rect& Snapshot::getLocalClip() {
    111     mat4 inverse;
    112     inverse.loadInverse(*transform);
    113 
    114     mLocalClip.set(mClipArea->getClipRect());
    115     inverse.mapRect(mLocalClip);
    116 
    117     return mLocalClip;
    118 }
    119 
    120 void Snapshot::resetClip(float left, float top, float right, float bottom) {
    121     // TODO: This is incorrect, when we start rendering into a new layer,
    122     // we may have to modify the previous snapshot's clip rect and clip
    123     // region if the previous restore() call did not restore the clip
    124     mClipArea = &mClipAreaRoot;
    125     setClip(left, top, right, bottom);
    126 }
    127 
    128 ///////////////////////////////////////////////////////////////////////////////
    129 // Transforms
    130 ///////////////////////////////////////////////////////////////////////////////
    131 
    132 void Snapshot::resetTransform(float x, float y, float z) {
    133 #if HWUI_NEW_OPS
    134     LOG_ALWAYS_FATAL("not supported - light center managed differently");
    135 #else
    136     // before resetting, map current light pos with inverse of current transform
    137     Vector3 center = mRelativeLightCenter;
    138     mat4 inverse;
    139     inverse.loadInverse(*transform);
    140     inverse.mapPoint3d(center);
    141     mRelativeLightCenter = center;
    142 
    143     transform = &mTransformRoot;
    144     transform->loadTranslate(x, y, z);
    145 #endif
    146 }
    147 
    148 void Snapshot::buildScreenSpaceTransform(Matrix4* outTransform) const {
    149 #if HWUI_NEW_OPS
    150     LOG_ALWAYS_FATAL("not supported - not needed by new ops");
    151 #else
    152     // build (reverse ordered) list of the stack of snapshots, terminated with a NULL
    153     Vector<const Snapshot*> snapshotList;
    154     snapshotList.push(nullptr);
    155     const Snapshot* current = this;
    156     do {
    157         snapshotList.push(current);
    158         current = current->previous;
    159     } while (current);
    160 
    161     // traverse the list, adding in each transform that contributes to the total transform
    162     outTransform->loadIdentity();
    163     for (size_t i = snapshotList.size() - 1; i > 0; i--) {
    164         // iterate down the stack
    165         const Snapshot* current = snapshotList[i];
    166         const Snapshot* next = snapshotList[i - 1];
    167         if (current->flags & kFlagIsFboLayer) {
    168             // if we've hit a layer, translate by the layer's draw offset
    169             outTransform->translate(current->layer->layer.left, current->layer->layer.top);
    170         }
    171         if (!next || (next->flags & kFlagIsFboLayer)) {
    172             // if this snapshot is last, or if this snapshot is last before an
    173             // FBO layer (which reset the transform), apply it
    174             outTransform->multiply(*(current->transform));
    175         }
    176     }
    177 #endif
    178 }
    179 
    180 ///////////////////////////////////////////////////////////////////////////////
    181 // Clipping round rect
    182 ///////////////////////////////////////////////////////////////////////////////
    183 
    184 void Snapshot::setClippingRoundRect(LinearAllocator& allocator, const Rect& bounds,
    185         float radius, bool highPriority) {
    186     if (bounds.isEmpty()) {
    187         mClipArea->setEmpty();
    188         return;
    189     }
    190 
    191     if (roundRectClipState && roundRectClipState->highPriority) {
    192         // ignore, don't replace, already have a high priority clip
    193         return;
    194     }
    195 
    196     RoundRectClipState* state = new (allocator) RoundRectClipState;
    197 
    198     state->highPriority = highPriority;
    199 
    200     // store the inverse drawing matrix
    201     Matrix4 roundRectDrawingMatrix = getOrthoMatrix();
    202     roundRectDrawingMatrix.multiply(*transform);
    203     state->matrix.loadInverse(roundRectDrawingMatrix);
    204 
    205     // compute area under rounded corners - only draws overlapping these rects need to be clipped
    206     for (int i = 0 ; i < 4; i++) {
    207         state->dangerRects[i] = bounds;
    208     }
    209     state->dangerRects[0].bottom = state->dangerRects[1].bottom = bounds.top + radius;
    210     state->dangerRects[0].right = state->dangerRects[2].right = bounds.left + radius;
    211     state->dangerRects[1].left = state->dangerRects[3].left = bounds.right - radius;
    212     state->dangerRects[2].top = state->dangerRects[3].top = bounds.bottom - radius;
    213     for (int i = 0; i < 4; i++) {
    214         transform->mapRect(state->dangerRects[i]);
    215 
    216         // round danger rects out as though they are AA geometry (since they essentially are)
    217         state->dangerRects[i].snapGeometryToPixelBoundaries(true);
    218     }
    219 
    220     // store RR area
    221     state->innerRect = bounds;
    222     state->innerRect.inset(radius);
    223     state->radius = radius;
    224 
    225     // store as immutable so, for this frame, pointer uniquely identifies this bundle of shader info
    226     roundRectClipState = state;
    227 }
    228 
    229 void Snapshot::setProjectionPathMask(LinearAllocator& allocator, const SkPath* path) {
    230 #if HWUI_NEW_OPS
    231     // TODO: remove allocator param for HWUI_NEW_OPS
    232     projectionPathMask = path;
    233 #else
    234     if (path) {
    235         ProjectionPathMask* mask = new (allocator) ProjectionPathMask;
    236         mask->projectionMask = path;
    237         buildScreenSpaceTransform(&(mask->projectionMaskTransform));
    238         projectionPathMask = mask;
    239     } else {
    240         projectionPathMask = nullptr;
    241     }
    242 #endif
    243 }
    244 
    245 static Snapshot* getClipRoot(Snapshot* target) {
    246     while (target->previous && target->previous->previous) {
    247         target = target->previous;
    248     }
    249     return target;
    250 }
    251 
    252 const ClipBase* Snapshot::serializeIntersectedClip(LinearAllocator& allocator,
    253         const ClipBase* recordedClip, const Matrix4& recordedClipTransform) {
    254     auto target = this;
    255     if (CC_UNLIKELY(recordedClip && recordedClip->intersectWithRoot)) {
    256         // Clip must be intersected with root, instead of current clip.
    257         target = getClipRoot(this);
    258     }
    259 
    260     return target->mClipArea->serializeIntersectedClip(allocator,
    261             recordedClip, recordedClipTransform);
    262 }
    263 
    264 void Snapshot::applyClip(const ClipBase* recordedClip, const Matrix4& transform) {
    265     if (CC_UNLIKELY(recordedClip && recordedClip->intersectWithRoot)) {
    266         // current clip is being replaced, but must intersect with clip root
    267         *mClipArea = *(getClipRoot(this)->mClipArea);
    268     }
    269     mClipArea->applyClip(recordedClip, transform);
    270 }
    271 
    272 ///////////////////////////////////////////////////////////////////////////////
    273 // Queries
    274 ///////////////////////////////////////////////////////////////////////////////
    275 
    276 bool Snapshot::isIgnored() const {
    277     return invisible || empty;
    278 }
    279 
    280 void Snapshot::dump() const {
    281     ALOGD("Snapshot %p, flags %x, prev %p, height %d, ignored %d, hasComplexClip %d",
    282             this, flags, previous, getViewportHeight(), isIgnored(), !mClipArea->isSimple());
    283     const Rect& clipRect(mClipArea->getClipRect());
    284     ALOGD("  ClipRect %.1f %.1f %.1f %.1f, clip simple %d",
    285             clipRect.left, clipRect.top, clipRect.right, clipRect.bottom, mClipArea->isSimple());
    286 
    287     ALOGD("  Transform (at %p):", transform);
    288     transform->dump();
    289 }
    290 
    291 }; // namespace uirenderer
    292 }; // namespace android
    293