Home | History | Annotate | Download | only in hwui 
      1 /*
      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 
     17 #define LOG_TAG "OpenGLRenderer"
     18 
     19 #include <SkCanvas.h>
     20 
     21 #include "StatefulBaseRenderer.h"
     22 
     23 #include "utils/MathUtils.h"
     24 
     25 namespace android {
     26 namespace uirenderer {
     27 
     28 StatefulBaseRenderer::StatefulBaseRenderer()
     29         : mDirtyClip(false)
     30         , mWidth(-1)
     31         , mHeight(-1)
     32         , mSaveCount(1)
     33         , mFirstSnapshot(new Snapshot)
     34         , mSnapshot(mFirstSnapshot) {
     35 }
     36 
     37 void StatefulBaseRenderer::initializeSaveStack(float clipLeft, float clipTop,
     38         float clipRight, float clipBottom, const Vector3& lightCenter) {
     39     mSnapshot = new Snapshot(mFirstSnapshot,
     40             SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
     41     mSnapshot->setClip(clipLeft, clipTop, clipRight, clipBottom);
     42     mSnapshot->fbo = getTargetFbo();
     43     mSnapshot->setRelativeLightCenter(lightCenter);
     44     mSaveCount = 1;
     45 }
     46 
     47 void StatefulBaseRenderer::setViewport(int width, int height) {
     48     mWidth = width;
     49     mHeight = height;
     50     mFirstSnapshot->initializeViewport(width, height);
     51     onViewportInitialized();
     52 
     53     // create a temporary 1st snapshot, so old snapshots are released,
     54     // and viewport can be queried safely.
     55     // TODO: remove, combine viewport + save stack initialization
     56     mSnapshot = new Snapshot(mFirstSnapshot,
     57             SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
     58     mSaveCount = 1;
     59 }
     60 
     61 ///////////////////////////////////////////////////////////////////////////////
     62 // Save (layer)
     63 ///////////////////////////////////////////////////////////////////////////////
     64 
     65 /**
     66  * Non-virtual implementation of save, guaranteed to save without side-effects
     67  *
     68  * The approach here and in restoreSnapshot(), allows subclasses to directly manipulate the save
     69  * stack, and ensures restoreToCount() doesn't call back into subclass overrides.
     70  */
     71 int StatefulBaseRenderer::saveSnapshot(int flags) {
     72     mSnapshot = new Snapshot(mSnapshot, flags);
     73     return mSaveCount++;
     74 }
     75 
     76 int StatefulBaseRenderer::save(int flags) {
     77     return saveSnapshot(flags);
     78 }
     79 
     80 /**
     81  * Non-virtual implementation of restore, guaranteed to restore without side-effects.
     82  */
     83 void StatefulBaseRenderer::restoreSnapshot() {
     84     sp<Snapshot> toRemove = mSnapshot;
     85     sp<Snapshot> toRestore = mSnapshot->previous;
     86 
     87     mSaveCount--;
     88     mSnapshot = toRestore;
     89 
     90     // subclass handles restore implementation
     91     onSnapshotRestored(*toRemove, *toRestore);
     92 }
     93 
     94 void StatefulBaseRenderer::restore() {
     95     if (mSaveCount > 1) {
     96         restoreSnapshot();
     97     }
     98 }
     99 
    100 void StatefulBaseRenderer::restoreToCount(int saveCount) {
    101     if (saveCount < 1) saveCount = 1;
    102 
    103     while (mSaveCount > saveCount) {
    104         restoreSnapshot();
    105     }
    106 }
    107 
    108 ///////////////////////////////////////////////////////////////////////////////
    109 // Matrix
    110 ///////////////////////////////////////////////////////////////////////////////
    111 
    112 void StatefulBaseRenderer::getMatrix(SkMatrix* matrix) const {
    113     mSnapshot->transform->copyTo(*matrix);
    114 }
    115 
    116 void StatefulBaseRenderer::translate(float dx, float dy, float dz) {
    117     mSnapshot->transform->translate(dx, dy, dz);
    118 }
    119 
    120 void StatefulBaseRenderer::rotate(float degrees) {
    121     mSnapshot->transform->rotate(degrees, 0.0f, 0.0f, 1.0f);
    122 }
    123 
    124 void StatefulBaseRenderer::scale(float sx, float sy) {
    125     mSnapshot->transform->scale(sx, sy, 1.0f);
    126 }
    127 
    128 void StatefulBaseRenderer::skew(float sx, float sy) {
    129     mSnapshot->transform->skew(sx, sy);
    130 }
    131 
    132 void StatefulBaseRenderer::setMatrix(const SkMatrix& matrix) {
    133     mSnapshot->transform->load(matrix);
    134 }
    135 
    136 void StatefulBaseRenderer::setMatrix(const Matrix4& matrix) {
    137     mSnapshot->transform->load(matrix);
    138 }
    139 
    140 void StatefulBaseRenderer::concatMatrix(const SkMatrix& matrix) {
    141     mat4 transform(matrix);
    142     mSnapshot->transform->multiply(transform);
    143 }
    144 
    145 void StatefulBaseRenderer::concatMatrix(const Matrix4& matrix) {
    146     mSnapshot->transform->multiply(matrix);
    147 }
    148 
    149 ///////////////////////////////////////////////////////////////////////////////
    150 // Clip
    151 ///////////////////////////////////////////////////////////////////////////////
    152 
    153 bool StatefulBaseRenderer::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) {
    154     if (CC_LIKELY(currentTransform()->rectToRect())) {
    155         mDirtyClip |= mSnapshot->clip(left, top, right, bottom, op);
    156         return !mSnapshot->clipRect->isEmpty();
    157     }
    158 
    159     SkPath path;
    160     path.addRect(left, top, right, bottom);
    161 
    162     return StatefulBaseRenderer::clipPath(&path, op);
    163 }
    164 
    165 bool StatefulBaseRenderer::clipPath(const SkPath* path, SkRegion::Op op) {
    166     SkMatrix transform;
    167     currentTransform()->copyTo(transform);
    168 
    169     SkPath transformed;
    170     path->transform(transform, &transformed);
    171 
    172     SkRegion clip;
    173     if (!mSnapshot->previous->clipRegion->isEmpty()) {
    174         clip.setRegion(*mSnapshot->previous->clipRegion);
    175     } else {
    176         if (mSnapshot->previous == firstSnapshot()) {
    177             clip.setRect(0, 0, getWidth(), getHeight());
    178         } else {
    179             Rect* bounds = mSnapshot->previous->clipRect;
    180             clip.setRect(bounds->left, bounds->top, bounds->right, bounds->bottom);
    181         }
    182     }
    183 
    184     SkRegion region;
    185     region.setPath(transformed, clip);
    186 
    187     // region is the transformed input path, masked by the previous clip
    188     mDirtyClip |= mSnapshot->clipRegionTransformed(region, op);
    189     return !mSnapshot->clipRect->isEmpty();
    190 }
    191 
    192 bool StatefulBaseRenderer::clipRegion(const SkRegion* region, SkRegion::Op op) {
    193     mDirtyClip |= mSnapshot->clipRegionTransformed(*region, op);
    194     return !mSnapshot->clipRect->isEmpty();
    195 }
    196 
    197 void StatefulBaseRenderer::setClippingOutline(LinearAllocator& allocator, const Outline* outline) {
    198     Rect bounds;
    199     float radius;
    200     if (!outline->getAsRoundRect(&bounds, &radius)) return; // only RR supported
    201 
    202     bool outlineIsRounded = MathUtils::isPositive(radius);
    203     if (!outlineIsRounded || currentTransform()->isSimple()) {
    204         // TODO: consider storing this rect separately, so that this can't be replaced with clip ops
    205         clipRect(bounds.left, bounds.top, bounds.right, bounds.bottom, SkRegion::kIntersect_Op);
    206     }
    207     if (outlineIsRounded) {
    208         setClippingRoundRect(allocator, bounds, radius, false);
    209     }
    210 }
    211 
    212 void StatefulBaseRenderer::setClippingRoundRect(LinearAllocator& allocator,
    213         const Rect& rect, float radius, bool highPriority) {
    214     mSnapshot->setClippingRoundRect(allocator, rect, radius, highPriority);
    215 }
    216 
    217 
    218 ///////////////////////////////////////////////////////////////////////////////
    219 // Quick Rejection
    220 ///////////////////////////////////////////////////////////////////////////////
    221 
    222 /**
    223  * Calculates whether content drawn within the passed bounds would be outside of, or intersect with
    224  * the clipRect. Does not modify the scissor.
    225  *
    226  * @param clipRequired if not null, will be set to true if element intersects clip
    227  *         (and wasn't rejected)
    228  *
    229  * @param snapOut if set, the geometry will be treated as having an AA ramp.
    230  *         See Rect::snapGeometryToPixelBoundaries()
    231  */
    232 bool StatefulBaseRenderer::calculateQuickRejectForScissor(float left, float top,
    233         float right, float bottom,
    234         bool* clipRequired, bool* roundRectClipRequired,
    235         bool snapOut) const {
    236     if (mSnapshot->isIgnored() || bottom <= top || right <= left) {
    237         return true;
    238     }
    239 
    240     Rect r(left, top, right, bottom);
    241     currentTransform()->mapRect(r);
    242     r.snapGeometryToPixelBoundaries(snapOut);
    243 
    244     Rect clipRect(*currentClipRect());
    245     clipRect.snapToPixelBoundaries();
    246 
    247     if (!clipRect.intersects(r)) return true;
    248 
    249     // clip is required if geometry intersects clip rect
    250     if (clipRequired) {
    251         *clipRequired = !clipRect.contains(r);
    252     }
    253 
    254     // round rect clip is required if RR clip exists, and geometry intersects its corners
    255     if (roundRectClipRequired) {
    256         *roundRectClipRequired = mSnapshot->roundRectClipState != NULL
    257                 && mSnapshot->roundRectClipState->areaRequiresRoundRectClip(r);
    258     }
    259     return false;
    260 }
    261 
    262 /**
    263  * Returns false if drawing won't be clipped out.
    264  *
    265  * Makes the decision conservatively, by rounding out the mapped rect before comparing with the
    266  * clipRect. To be used when perfect, pixel accuracy is not possible (esp. with tessellation) but
    267  * rejection is still desired.
    268  *
    269  * This function, unlike quickRejectSetupScissor, should be used where precise geometry information
    270  * isn't known (esp. when geometry adjusts based on scale). Generally, this will be first pass
    271  * rejection where precise rejection isn't important, or precise information isn't available.
    272  */
    273 bool StatefulBaseRenderer::quickRejectConservative(float left, float top,
    274         float right, float bottom) const {
    275     if (mSnapshot->isIgnored() || bottom <= top || right <= left) {
    276         return true;
    277     }
    278 
    279     Rect r(left, top, right, bottom);
    280     currentTransform()->mapRect(r);
    281     r.roundOut(); // rounded out to be conservative
    282 
    283     Rect clipRect(*currentClipRect());
    284     clipRect.snapToPixelBoundaries();
    285 
    286     if (!clipRect.intersects(r)) return true;
    287 
    288     return false;
    289 }
    290 
    291 }; // namespace uirenderer
    292 }; // namespace android
    293