Home | History | Annotate | Download | only in hwui 
      1 /*
      2  * Copyright (C) 2010 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 #ifndef ANDROID_HWUI_SNAPSHOT_H
     18 #define ANDROID_HWUI_SNAPSHOT_H
     19 
     20 #include <GLES2/gl2.h>
     21 #include <GLES2/gl2ext.h>
     22 
     23 #include <utils/RefBase.h>
     24 #include <ui/Region.h>
     25 
     26 #include <SkRegion.h>
     27 
     28 #include "Layer.h"
     29 #include "Matrix.h"
     30 #include "Rect.h"
     31 
     32 namespace android {
     33 namespace uirenderer {
     34 
     35 /**
     36  * A snapshot holds information about the current state of the rendering
     37  * surface. A snapshot is usually created whenever the user calls save()
     38  * and discarded when the user calls restore(). Once a snapshot is created,
     39  * it can hold information for deferred rendering.
     40  *
     41  * Each snapshot has a link to a previous snapshot, indicating the previous
     42  * state of the renderer.
     43  */
     44 class Snapshot: public LightRefBase<Snapshot> {
     45 public:
     46 
     47     Snapshot();
     48     Snapshot(const sp<Snapshot>& s, int saveFlags);
     49 
     50     /**
     51      * Various flags set on ::flags.
     52      */
     53     enum Flags {
     54         /**
     55          * Indicates that the clip region was modified. When this
     56          * snapshot is restored so must the clip.
     57          */
     58         kFlagClipSet = 0x1,
     59         /**
     60          * Indicates that this snapshot was created when saving
     61          * a new layer.
     62          */
     63         kFlagIsLayer = 0x2,
     64         /**
     65          * Indicates that this snapshot is a special type of layer
     66          * backed by an FBO. This flag only makes sense when the
     67          * flag kFlagIsLayer is also set.
     68          */
     69         kFlagIsFboLayer = 0x4,
     70         /**
     71          * Indicates that this snapshot has changed the ortho matrix.
     72          */
     73         kFlagDirtyOrtho = 0x8,
     74         /**
     75          * Indicates that this snapshot or an ancestor snapshot is
     76          * an FBO layer.
     77          */
     78         kFlagFboTarget = 0x10
     79     };
     80 
     81     /**
     82      * Modifies the current clip with the new clip rectangle and
     83      * the specified operation. The specified rectangle is transformed
     84      * by this snapshot's trasnformation.
     85      */
     86     bool clip(float left, float top, float right, float bottom,
     87             SkRegion::Op op = SkRegion::kIntersect_Op);
     88 
     89     /**
     90      * Modifies the current clip with the new clip rectangle and
     91      * the specified operation. The specified rectangle is considered
     92      * already transformed.
     93      */
     94     bool clipTransformed(const Rect& r, SkRegion::Op op = SkRegion::kIntersect_Op);
     95 
     96     /**
     97      * Sets the current clip.
     98      */
     99     void setClip(float left, float top, float right, float bottom);
    100 
    101     /**
    102      * Returns the current clip in local coordinates. The clip rect is
    103      * transformed by the inverse transform matrix.
    104      */
    105     const Rect& getLocalClip();
    106 
    107     /**
    108      * Resets the clip to the specified rect.
    109      */
    110     void resetClip(float left, float top, float right, float bottom);
    111 
    112     /**
    113      * Resets the current transform to a pure 3D translation.
    114      */
    115     void resetTransform(float x, float y, float z);
    116 
    117     /**
    118      * Indicates whether this snapshot should be ignored. A snapshot
    119      * is typicalled ignored if its layer is invisible or empty.
    120      */
    121     bool isIgnored() const;
    122 
    123     /**
    124      * Dirty flags.
    125      */
    126     int flags;
    127 
    128     /**
    129      * Previous snapshot.
    130      */
    131     sp<Snapshot> previous;
    132 
    133     /**
    134      * Only set when the flag kFlagIsLayer is set.
    135      *
    136      * This snapshot does not own the layer, this pointer must not be freed.
    137      */
    138     Layer* layer;
    139 
    140     /**
    141      * Target FBO used for rendering. Set to 0 when rendering directly
    142      * into the framebuffer.
    143      */
    144     GLuint fbo;
    145 
    146     /**
    147      * Indicates that this snapshot is invisible and nothing should be drawn
    148      * inside it. This flag is set only when the layer clips drawing to its
    149      * bounds and is passed to subsequent snapshots.
    150      */
    151     bool invisible;
    152 
    153     /**
    154      * If set to true, the layer will not be composited. This is similar to
    155      * invisible but this flag is not passed to subsequent snapshots.
    156      */
    157     bool empty;
    158 
    159     /**
    160      * Current viewport.
    161      */
    162     Rect viewport;
    163 
    164     /**
    165      * Height of the framebuffer the snapshot is rendering into.
    166      */
    167     int height;
    168 
    169     /**
    170      * Contains the previous ortho matrix.
    171      */
    172     mat4 orthoMatrix;
    173 
    174     /**
    175      * Local transformation. Holds the current translation, scale and
    176      * rotation values.
    177      *
    178      * This is a reference to a matrix owned by this snapshot or another
    179      *  snapshot. This pointer must not be freed. See ::mTransformRoot.
    180      */
    181     mat4* transform;
    182 
    183     /**
    184      * Current clip rect. The clip is stored in canvas-space coordinates,
    185      * (screen-space coordinates in the regular case.)
    186      *
    187      * This is a reference to a rect owned by this snapshot or another
    188      * snapshot. This pointer must not be freed. See ::mClipRectRoot.
    189      */
    190     Rect* clipRect;
    191 
    192     /**
    193      * Current clip region. The clip is stored in canvas-space coordinates,
    194      * (screen-space coordinates in the regular case.)
    195      *
    196      * This is a reference to a region owned by this snapshot or another
    197      * snapshot. This pointer must not be freed. See ::mClipRegionRoot.
    198      *
    199      * This field is used only if STENCIL_BUFFER_SIZE is > 0.
    200      */
    201     Region* clipRegion;
    202 
    203     /**
    204      * The ancestor layer's dirty region.
    205      *
    206      * This is a reference to a region owned by a layer. This pointer must
    207      * not be freed.
    208      */
    209     Region* region;
    210 
    211     /**
    212      * Current alpha value. This value is 1 by default, but may be set by a DisplayList which
    213      * has translucent rendering in a non-overlapping View. This value will be used by
    214      * the renderer to set the alpha in the current color being used for ensuing drawing
    215      * operations. The value is inherited by child snapshots because the same value should
    216      * be applied to descendents of the current DisplayList (for example, a TextView contains
    217      * the base alpha value which should be applied to the child DisplayLists used for drawing
    218      * the actual text).
    219      */
    220     float alpha;
    221 
    222 private:
    223     void ensureClipRegion();
    224     void copyClipRectFromRegion();
    225 
    226     bool clipRegionOr(float left, float top, float right, float bottom);
    227     bool clipRegionXor(float left, float top, float right, float bottom);
    228     bool clipRegionAnd(float left, float top, float right, float bottom);
    229     bool clipRegionNand(float left, float top, float right, float bottom);
    230 
    231     mat4 mTransformRoot;
    232     Rect mClipRectRoot;
    233     Rect mLocalClip;
    234 
    235 #if STENCIL_BUFFER_SIZE
    236     Region mClipRegionRoot;
    237 #endif
    238 
    239 }; // class Snapshot
    240 
    241 }; // namespace uirenderer
    242 }; // namespace android
    243 
    244 #endif // ANDROID_HWUI_SNAPSHOT_H
    245