Home | History | Annotate | Download | only in hwui 
      1 /*
      2  * Copyright (C) 2015 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 #include "ClipArea.h"
     17 
     18 #include "utils/LinearAllocator.h"
     19 
     20 #include <SkPath.h>
     21 #include <limits>
     22 #include <type_traits>
     23 
     24 namespace android {
     25 namespace uirenderer {
     26 
     27 static void handlePoint(Rect& transformedBounds, const Matrix4& transform, float x, float y) {
     28     Vertex v = {x, y};
     29     transform.mapPoint(v.x, v.y);
     30     transformedBounds.expandToCover(v.x, v.y);
     31 }
     32 
     33 Rect transformAndCalculateBounds(const Rect& r, const Matrix4& transform) {
     34     const float kMinFloat = std::numeric_limits<float>::lowest();
     35     const float kMaxFloat = std::numeric_limits<float>::max();
     36     Rect transformedBounds = { kMaxFloat, kMaxFloat, kMinFloat, kMinFloat };
     37     handlePoint(transformedBounds, transform, r.left, r.top);
     38     handlePoint(transformedBounds, transform, r.right, r.top);
     39     handlePoint(transformedBounds, transform, r.left, r.bottom);
     40     handlePoint(transformedBounds, transform, r.right, r.bottom);
     41     return transformedBounds;
     42 }
     43 
     44 void ClipBase::dump() const {
     45     ALOGD("mode %d" RECT_STRING, mode, RECT_ARGS(rect));
     46 }
     47 
     48 /*
     49  * TransformedRectangle
     50  */
     51 
     52 TransformedRectangle::TransformedRectangle() {
     53 }
     54 
     55 TransformedRectangle::TransformedRectangle(const Rect& bounds,
     56         const Matrix4& transform)
     57         : mBounds(bounds)
     58         , mTransform(transform) {
     59 }
     60 
     61 bool TransformedRectangle::canSimplyIntersectWith(
     62         const TransformedRectangle& other) const {
     63 
     64     return mTransform == other.mTransform;
     65 }
     66 
     67 void TransformedRectangle::intersectWith(const TransformedRectangle& other) {
     68     mBounds.doIntersect(other.mBounds);
     69 }
     70 
     71 bool TransformedRectangle::isEmpty() const {
     72     return mBounds.isEmpty();
     73 }
     74 
     75 /*
     76  * RectangleList
     77  */
     78 
     79 RectangleList::RectangleList()
     80         : mTransformedRectanglesCount(0) {
     81 }
     82 
     83 bool RectangleList::isEmpty() const {
     84     if (mTransformedRectanglesCount < 1) {
     85         return true;
     86     }
     87 
     88     for (int i = 0; i < mTransformedRectanglesCount; i++) {
     89         if (mTransformedRectangles[i].isEmpty()) {
     90             return true;
     91         }
     92     }
     93     return false;
     94 }
     95 
     96 int RectangleList::getTransformedRectanglesCount() const {
     97     return mTransformedRectanglesCount;
     98 }
     99 
    100 const TransformedRectangle& RectangleList::getTransformedRectangle(int i) const {
    101     return mTransformedRectangles[i];
    102 }
    103 
    104 void RectangleList::setEmpty() {
    105     mTransformedRectanglesCount = 0;
    106 }
    107 
    108 void RectangleList::set(const Rect& bounds, const Matrix4& transform) {
    109     mTransformedRectanglesCount = 1;
    110     mTransformedRectangles[0] = TransformedRectangle(bounds, transform);
    111 }
    112 
    113 bool RectangleList::intersectWith(const Rect& bounds,
    114         const Matrix4& transform) {
    115     TransformedRectangle newRectangle(bounds, transform);
    116 
    117     // Try to find a rectangle with a compatible transformation
    118     int index = 0;
    119     for (; index < mTransformedRectanglesCount; index++) {
    120         TransformedRectangle& tr(mTransformedRectangles[index]);
    121         if (tr.canSimplyIntersectWith(newRectangle)) {
    122             tr.intersectWith(newRectangle);
    123             return true;
    124         }
    125     }
    126 
    127     // Add it to the list if there is room
    128     if (index < kMaxTransformedRectangles) {
    129         mTransformedRectangles[index] = newRectangle;
    130         mTransformedRectanglesCount += 1;
    131         return true;
    132     }
    133 
    134     // This rectangle list is full
    135     return false;
    136 }
    137 
    138 Rect RectangleList::calculateBounds() const {
    139     Rect bounds;
    140     for (int index = 0; index < mTransformedRectanglesCount; index++) {
    141         const TransformedRectangle& tr(mTransformedRectangles[index]);
    142         if (index == 0) {
    143             bounds = tr.transformedBounds();
    144         } else {
    145             bounds.doIntersect(tr.transformedBounds());
    146         }
    147     }
    148     return bounds;
    149 }
    150 
    151 static SkPath pathFromTransformedRectangle(const Rect& bounds,
    152         const Matrix4& transform) {
    153     SkPath rectPath;
    154     SkPath rectPathTransformed;
    155     rectPath.addRect(bounds.left, bounds.top, bounds.right, bounds.bottom);
    156     SkMatrix skTransform;
    157     transform.copyTo(skTransform);
    158     rectPath.transform(skTransform, &rectPathTransformed);
    159     return rectPathTransformed;
    160 }
    161 
    162 SkRegion RectangleList::convertToRegion(const SkRegion& clip) const {
    163     SkRegion rectangleListAsRegion;
    164     for (int index = 0; index < mTransformedRectanglesCount; index++) {
    165         const TransformedRectangle& tr(mTransformedRectangles[index]);
    166         SkPath rectPathTransformed = pathFromTransformedRectangle(
    167                 tr.getBounds(), tr.getTransform());
    168         if (index == 0) {
    169             rectangleListAsRegion.setPath(rectPathTransformed, clip);
    170         } else {
    171             SkRegion rectRegion;
    172             rectRegion.setPath(rectPathTransformed, clip);
    173             rectangleListAsRegion.op(rectRegion, SkRegion::kIntersect_Op);
    174         }
    175     }
    176     return rectangleListAsRegion;
    177 }
    178 
    179 void RectangleList::transform(const Matrix4& transform) {
    180     for (int index = 0; index < mTransformedRectanglesCount; index++) {
    181         mTransformedRectangles[index].transform(transform);
    182     }
    183 }
    184 
    185 /*
    186  * ClipArea
    187  */
    188 
    189 ClipArea::ClipArea()
    190         : mMode(ClipMode::Rectangle) {
    191 }
    192 
    193 /*
    194  * Interface
    195  */
    196 
    197 void ClipArea::setViewportDimensions(int width, int height) {
    198     mPostViewportClipObserved = false;
    199     mViewportBounds.set(0, 0, width, height);
    200     mClipRect = mViewportBounds;
    201 }
    202 
    203 void ClipArea::setEmpty() {
    204     onClipUpdated();
    205     mMode = ClipMode::Rectangle;
    206     mClipRect.setEmpty();
    207     mClipRegion.setEmpty();
    208     mRectangleList.setEmpty();
    209 }
    210 
    211 void ClipArea::setClip(float left, float top, float right, float bottom) {
    212     onClipUpdated();
    213     mMode = ClipMode::Rectangle;
    214     mClipRect.set(left, top, right, bottom);
    215     mClipRegion.setEmpty();
    216 }
    217 
    218 void ClipArea::clipRectWithTransform(const Rect& r, const mat4* transform,
    219         SkRegion::Op op) {
    220     if (op == SkRegion::kReplace_Op) mReplaceOpObserved = true;
    221     if (!mPostViewportClipObserved && op == SkRegion::kIntersect_Op) op = SkRegion::kReplace_Op;
    222     onClipUpdated();
    223     switch (mMode) {
    224     case ClipMode::Rectangle:
    225         rectangleModeClipRectWithTransform(r, transform, op);
    226         break;
    227     case ClipMode::RectangleList:
    228         rectangleListModeClipRectWithTransform(r, transform, op);
    229         break;
    230     case ClipMode::Region:
    231         regionModeClipRectWithTransform(r, transform, op);
    232         break;
    233     }
    234 }
    235 
    236 void ClipArea::clipRegion(const SkRegion& region, SkRegion::Op op) {
    237     if (op == SkRegion::kReplace_Op) mReplaceOpObserved = true;
    238     if (!mPostViewportClipObserved && op == SkRegion::kIntersect_Op) op = SkRegion::kReplace_Op;
    239     onClipUpdated();
    240     enterRegionMode();
    241     mClipRegion.op(region, op);
    242     onClipRegionUpdated();
    243 }
    244 
    245 void ClipArea::clipPathWithTransform(const SkPath& path, const mat4* transform,
    246         SkRegion::Op op) {
    247     if (op == SkRegion::kReplace_Op) mReplaceOpObserved = true;
    248     if (!mPostViewportClipObserved && op == SkRegion::kIntersect_Op) op = SkRegion::kReplace_Op;
    249     onClipUpdated();
    250     SkMatrix skTransform;
    251     transform->copyTo(skTransform);
    252     SkPath transformed;
    253     path.transform(skTransform, &transformed);
    254     SkRegion region;
    255     regionFromPath(transformed, region);
    256     enterRegionMode();
    257     mClipRegion.op(region, op);
    258     onClipRegionUpdated();
    259 }
    260 
    261 /*
    262  * Rectangle mode
    263  */
    264 
    265 void ClipArea::enterRectangleMode() {
    266     // Entering rectangle mode discards any
    267     // existing clipping information from the other modes.
    268     // The only way this occurs is by a clip setting operation.
    269     mMode = ClipMode::Rectangle;
    270 }
    271 
    272 void ClipArea::rectangleModeClipRectWithTransform(const Rect& r,
    273         const mat4* transform, SkRegion::Op op) {
    274 
    275     if (op == SkRegion::kReplace_Op && transform->rectToRect()) {
    276         mClipRect = r;
    277         transform->mapRect(mClipRect);
    278         return;
    279     } else if (op != SkRegion::kIntersect_Op) {
    280         enterRegionMode();
    281         regionModeClipRectWithTransform(r, transform, op);
    282         return;
    283     }
    284 
    285     if (transform->rectToRect()) {
    286         Rect transformed(r);
    287         transform->mapRect(transformed);
    288         mClipRect.doIntersect(transformed);
    289         return;
    290     }
    291 
    292     enterRectangleListMode();
    293     rectangleListModeClipRectWithTransform(r, transform, op);
    294 }
    295 
    296 /*
    297  * RectangleList mode implementation
    298  */
    299 
    300 void ClipArea::enterRectangleListMode() {
    301     // Is is only legal to enter rectangle list mode from
    302     // rectangle mode, since rectangle list mode cannot represent
    303     // all clip areas that can be represented by a region.
    304     ALOG_ASSERT(mMode == ClipMode::Rectangle);
    305     mMode = ClipMode::RectangleList;
    306     mRectangleList.set(mClipRect, Matrix4::identity());
    307 }
    308 
    309 void ClipArea::rectangleListModeClipRectWithTransform(const Rect& r,
    310         const mat4* transform, SkRegion::Op op) {
    311     if (op != SkRegion::kIntersect_Op
    312             || !mRectangleList.intersectWith(r, *transform)) {
    313         enterRegionMode();
    314         regionModeClipRectWithTransform(r, transform, op);
    315     }
    316 }
    317 
    318 /*
    319  * Region mode implementation
    320  */
    321 
    322 void ClipArea::enterRegionMode() {
    323     ClipMode oldMode = mMode;
    324     mMode = ClipMode::Region;
    325     if (oldMode != ClipMode::Region) {
    326         if (oldMode == ClipMode::Rectangle) {
    327             mClipRegion.setRect(mClipRect.toSkIRect());
    328         } else {
    329             mClipRegion = mRectangleList.convertToRegion(createViewportRegion());
    330             onClipRegionUpdated();
    331         }
    332     }
    333 }
    334 
    335 void ClipArea::regionModeClipRectWithTransform(const Rect& r,
    336         const mat4* transform, SkRegion::Op op) {
    337     SkPath transformedRect = pathFromTransformedRectangle(r, *transform);
    338     SkRegion transformedRectRegion;
    339     regionFromPath(transformedRect, transformedRectRegion);
    340     mClipRegion.op(transformedRectRegion, op);
    341     onClipRegionUpdated();
    342 }
    343 
    344 void ClipArea::onClipRegionUpdated() {
    345     if (!mClipRegion.isEmpty()) {
    346         mClipRect.set(mClipRegion.getBounds());
    347 
    348         if (mClipRegion.isRect()) {
    349             mClipRegion.setEmpty();
    350             enterRectangleMode();
    351         }
    352     } else {
    353         mClipRect.setEmpty();
    354     }
    355 }
    356 
    357 /**
    358  * Clip serialization
    359  */
    360 
    361 const ClipBase* ClipArea::serializeClip(LinearAllocator& allocator) {
    362     if (!mPostViewportClipObserved) {
    363         // Only initial clip-to-viewport observed, so no serialization of clip necessary
    364         return nullptr;
    365     }
    366 
    367     static_assert(std::is_trivially_destructible<Rect>::value,
    368             "expect Rect to be trivially destructible");
    369     static_assert(std::is_trivially_destructible<RectangleList>::value,
    370             "expect RectangleList to be trivially destructible");
    371 
    372     if (mLastSerialization == nullptr) {
    373         ClipBase* serialization = nullptr;
    374         switch (mMode) {
    375         case ClipMode::Rectangle:
    376             serialization = allocator.create<ClipRect>(mClipRect);
    377             break;
    378         case ClipMode::RectangleList:
    379             serialization = allocator.create<ClipRectList>(mRectangleList);
    380             serialization->rect = mRectangleList.calculateBounds();
    381             break;
    382         case ClipMode::Region:
    383             serialization = allocator.create<ClipRegion>(mClipRegion);
    384             serialization->rect.set(mClipRegion.getBounds());
    385             break;
    386         }
    387         serialization->intersectWithRoot = mReplaceOpObserved;
    388         // TODO: this is only done for draw time, should eventually avoid for record time
    389         serialization->rect.snapToPixelBoundaries();
    390         mLastSerialization = serialization;
    391     }
    392     return mLastSerialization;
    393 }
    394 
    395 inline static const RectangleList& getRectList(const ClipBase* scb) {
    396     return reinterpret_cast<const ClipRectList*>(scb)->rectList;
    397 }
    398 
    399 inline static const SkRegion& getRegion(const ClipBase* scb) {
    400     return reinterpret_cast<const ClipRegion*>(scb)->region;
    401 }
    402 
    403 // Conservative check for too many rectangles to fit in rectangle list.
    404 // For simplicity, doesn't account for rect merging
    405 static bool cannotFitInRectangleList(const ClipArea& clipArea, const ClipBase* scb) {
    406     int currentRectCount = clipArea.isRectangleList()
    407             ? clipArea.getRectangleList().getTransformedRectanglesCount()
    408             : 1;
    409     int recordedRectCount = (scb->mode == ClipMode::RectangleList)
    410             ? getRectList(scb).getTransformedRectanglesCount()
    411             : 1;
    412     return currentRectCount + recordedRectCount > RectangleList::kMaxTransformedRectangles;
    413 }
    414 
    415 static const ClipRect sEmptyClipRect(Rect(0, 0));
    416 
    417 const ClipBase* ClipArea::serializeIntersectedClip(LinearAllocator& allocator,
    418         const ClipBase* recordedClip, const Matrix4& recordedClipTransform) {
    419 
    420     // if no recordedClip passed, just serialize current state
    421     if (!recordedClip) return serializeClip(allocator);
    422 
    423     // if either is empty, clip is empty
    424     if (CC_UNLIKELY(recordedClip->rect.isEmpty())|| mClipRect.isEmpty()) return &sEmptyClipRect;
    425 
    426     if (!mLastResolutionResult
    427             || recordedClip != mLastResolutionClip
    428             || recordedClipTransform != mLastResolutionTransform) {
    429         mLastResolutionClip = recordedClip;
    430         mLastResolutionTransform = recordedClipTransform;
    431 
    432         if (CC_LIKELY(mMode == ClipMode::Rectangle
    433                 && recordedClip->mode == ClipMode::Rectangle
    434                 && recordedClipTransform.rectToRect())) {
    435             // common case - result is a single rectangle
    436             auto rectClip = allocator.create<ClipRect>(recordedClip->rect);
    437             recordedClipTransform.mapRect(rectClip->rect);
    438             rectClip->rect.doIntersect(mClipRect);
    439             rectClip->rect.snapToPixelBoundaries();
    440             mLastResolutionResult = rectClip;
    441         } else if (CC_UNLIKELY(mMode == ClipMode::Region
    442                 || recordedClip->mode == ClipMode::Region
    443                 || cannotFitInRectangleList(*this, recordedClip))) {
    444             // region case
    445             SkRegion other;
    446             switch (recordedClip->mode) {
    447             case ClipMode::Rectangle:
    448                 if (CC_LIKELY(recordedClipTransform.rectToRect())) {
    449                     // simple transform, skip creating SkPath
    450                     Rect resultClip(recordedClip->rect);
    451                     recordedClipTransform.mapRect(resultClip);
    452                     other.setRect(resultClip.toSkIRect());
    453                 } else {
    454                     SkPath transformedRect = pathFromTransformedRectangle(recordedClip->rect,
    455                             recordedClipTransform);
    456                     other.setPath(transformedRect, createViewportRegion());
    457                 }
    458                 break;
    459             case ClipMode::RectangleList: {
    460                 RectangleList transformedList(getRectList(recordedClip));
    461                 transformedList.transform(recordedClipTransform);
    462                 other = transformedList.convertToRegion(createViewportRegion());
    463                 break;
    464             }
    465             case ClipMode::Region:
    466                 other = getRegion(recordedClip);
    467                 applyTransformToRegion(recordedClipTransform, &other);
    468             }
    469 
    470             ClipRegion* regionClip = allocator.create<ClipRegion>();
    471             switch (mMode) {
    472             case ClipMode::Rectangle:
    473                 regionClip->region.op(mClipRect.toSkIRect(), other, SkRegion::kIntersect_Op);
    474                 break;
    475             case ClipMode::RectangleList:
    476                 regionClip->region.op(mRectangleList.convertToRegion(createViewportRegion()),
    477                         other, SkRegion::kIntersect_Op);
    478                 break;
    479             case ClipMode::Region:
    480                 regionClip->region.op(mClipRegion, other, SkRegion::kIntersect_Op);
    481                 break;
    482             }
    483             // Don't need to snap, since region's in int bounds
    484             regionClip->rect.set(regionClip->region.getBounds());
    485             mLastResolutionResult = regionClip;
    486         } else {
    487             auto rectListClip = allocator.create<ClipRectList>(mRectangleList);
    488             auto&& rectList = rectListClip->rectList;
    489             if (mMode == ClipMode::Rectangle) {
    490                 rectList.set(mClipRect, Matrix4::identity());
    491             }
    492 
    493             if (recordedClip->mode == ClipMode::Rectangle) {
    494                 rectList.intersectWith(recordedClip->rect, recordedClipTransform);
    495             } else {
    496                 const RectangleList& other = getRectList(recordedClip);
    497                 for (int i = 0; i < other.getTransformedRectanglesCount(); i++) {
    498                     auto&& tr = other.getTransformedRectangle(i);
    499                     Matrix4 totalTransform(recordedClipTransform);
    500                     totalTransform.multiply(tr.getTransform());
    501                     rectList.intersectWith(tr.getBounds(), totalTransform);
    502                 }
    503             }
    504             rectListClip->rect = rectList.calculateBounds();
    505             rectListClip->rect.snapToPixelBoundaries();
    506             mLastResolutionResult = rectListClip;
    507         }
    508     }
    509     return mLastResolutionResult;
    510 }
    511 
    512 void ClipArea::applyClip(const ClipBase* clip, const Matrix4& transform) {
    513     if (!clip) return; // nothing to do
    514 
    515     if (CC_LIKELY(clip->mode == ClipMode::Rectangle)) {
    516         clipRectWithTransform(clip->rect, &transform, SkRegion::kIntersect_Op);
    517     } else if (CC_LIKELY(clip->mode == ClipMode::RectangleList)) {
    518         auto&& rectList = getRectList(clip);
    519         for (int i = 0; i < rectList.getTransformedRectanglesCount(); i++) {
    520             auto&& tr = rectList.getTransformedRectangle(i);
    521             Matrix4 totalTransform(transform);
    522             totalTransform.multiply(tr.getTransform());
    523             clipRectWithTransform(tr.getBounds(), &totalTransform, SkRegion::kIntersect_Op);
    524         }
    525     } else {
    526         SkRegion region(getRegion(clip));
    527         applyTransformToRegion(transform, &region);
    528         clipRegion(region, SkRegion::kIntersect_Op);
    529     }
    530 }
    531 
    532 void ClipArea::applyTransformToRegion(const Matrix4& transform, SkRegion* region) {
    533     if (transform.rectToRect() && !transform.isPureTranslate()) {
    534         // handle matrices with scale manually by mapping each rect
    535         SkRegion other;
    536         SkRegion::Iterator it(*region);
    537         while (!it.done()) {
    538             Rect rect(it.rect());
    539             transform.mapRect(rect);
    540             rect.snapGeometryToPixelBoundaries(true);
    541             other.op(rect.left, rect.top, rect.right, rect.bottom, SkRegion::kUnion_Op);
    542             it.next();
    543         }
    544         region->swap(other);
    545     } else {
    546         // TODO: handle non-translate transforms properly!
    547         region->translate(transform.getTranslateX(), transform.getTranslateY());
    548     }
    549 }
    550 
    551 } /* namespace uirenderer */
    552 } /* namespace android */
    553