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/LinearAllocator.h>
     24 #include <utils/RefBase.h>
     25 #include <ui/Region.h>
     26 
     27 #include <SkRegion.h>
     28 
     29 #include "ClipArea.h"
     30 #include "Layer.h"
     31 #include "Matrix.h"
     32 #include "Outline.h"
     33 #include "Rect.h"
     34 #include "utils/Macros.h"
     35 
     36 namespace android {
     37 namespace uirenderer {
     38 
     39 /**
     40  * Temporary structure holding information for a single outline clip.
     41  *
     42  * These structures are treated as immutable once created, and only exist for a single frame, which
     43  * is why they may only be allocated with a LinearAllocator.
     44  */
     45 class RoundRectClipState {
     46 public:
     47     static void* operator new(size_t size) = delete;
     48     static void* operator new(size_t size, LinearAllocator& allocator) {
     49         return allocator.alloc<RoundRectClipState>(size);
     50     }
     51 
     52     bool areaRequiresRoundRectClip(const Rect& rect) const {
     53         return rect.intersects(dangerRects[0])
     54                 || rect.intersects(dangerRects[1])
     55                 || rect.intersects(dangerRects[2])
     56                 || rect.intersects(dangerRects[3]);
     57     }
     58 
     59     bool highPriority;
     60     Matrix4 matrix;
     61     Rect dangerRects[4];
     62     Rect innerRect;
     63     float radius;
     64 };
     65 
     66 // TODO: remove for HWUI_NEW_OPS
     67 class ProjectionPathMask {
     68 public:
     69     static void* operator new(size_t size) = delete;
     70     static void* operator new(size_t size, LinearAllocator& allocator) {
     71         return allocator.alloc<ProjectionPathMask>(size);
     72     }
     73 
     74     const SkPath* projectionMask;
     75     Matrix4 projectionMaskTransform;
     76 };
     77 
     78 /**
     79  * A snapshot holds information about the current state of the rendering
     80  * surface. A snapshot is usually created whenever the user calls save()
     81  * and discarded when the user calls restore(). Once a snapshot is created,
     82  * it can hold information for deferred rendering.
     83  *
     84  * Each snapshot has a link to a previous snapshot, indicating the previous
     85  * state of the renderer.
     86  */
     87 class Snapshot {
     88 public:
     89 
     90     Snapshot();
     91     Snapshot(Snapshot* s, int saveFlags);
     92 
     93     /**
     94      * Various flags set on ::flags.
     95      */
     96     enum Flags {
     97         /**
     98          * Indicates that the clip region was modified. When this
     99          * snapshot is restored so must the clip.
    100          */
    101         kFlagClipSet = 0x1,
    102         /**
    103          * Indicates that this snapshot was created when saving
    104          * a new layer.
    105          */
    106         kFlagIsLayer = 0x2,
    107         /**
    108          * Indicates that this snapshot is a special type of layer
    109          * backed by an FBO. This flag only makes sense when the
    110          * flag kFlagIsLayer is also set.
    111          *
    112          * Viewport has been modified to fit the new Fbo, and must be
    113          * restored when this snapshot is restored.
    114          */
    115         kFlagIsFboLayer = 0x4,
    116         /**
    117          * Indicates that this snapshot or an ancestor snapshot is
    118          * an FBO layer.
    119          */
    120         kFlagFboTarget = 0x8, // TODO: remove for HWUI_NEW_OPS
    121     };
    122 
    123     /**
    124      * Modifies the current clip with the new clip rectangle and
    125      * the specified operation. The specified rectangle is transformed
    126      * by this snapshot's trasnformation.
    127      */
    128     void clip(const Rect& localClip, SkRegion::Op op);
    129 
    130     /**
    131      * Modifies the current clip with the new clip rectangle and
    132      * the specified operation. The specified rectangle is considered
    133      * already transformed.
    134      */
    135     void clipTransformed(const Rect& r, SkRegion::Op op = SkRegion::kIntersect_Op);
    136 
    137     /**
    138      * Modifies the current clip with the specified region and operation.
    139      * The specified region is considered already transformed.
    140      */
    141     void clipRegionTransformed(const SkRegion& region, SkRegion::Op op);
    142 
    143     /**
    144      * Modifies the current clip with the specified path and operation.
    145      */
    146     void clipPath(const SkPath& path, SkRegion::Op op);
    147 
    148     /**
    149      * Sets the current clip.
    150      */
    151     void setClip(float left, float top, float right, float bottom);
    152 
    153     /**
    154      * Returns the current clip in local coordinates. The clip rect is
    155      * transformed by the inverse transform matrix.
    156      */
    157     ANDROID_API const Rect& getLocalClip();
    158 
    159     /**
    160      * Returns the current clip in render target coordinates.
    161      */
    162     const Rect& getRenderTargetClip() const { return mClipArea->getClipRect(); }
    163 
    164     /*
    165      * Accessor functions so that the clip area can stay private
    166      */
    167     bool clipIsEmpty() const { return mClipArea->isEmpty(); }
    168     const SkRegion& getClipRegion() const { return mClipArea->getClipRegion(); }
    169     bool clipIsSimple() const { return mClipArea->isSimple(); }
    170     const ClipArea& getClipArea() const { return *mClipArea; }
    171     ClipArea& mutateClipArea() { return *mClipArea; }
    172 
    173     WARN_UNUSED_RESULT const ClipBase* serializeIntersectedClip(LinearAllocator& allocator,
    174             const ClipBase* recordedClip, const Matrix4& recordedClipTransform);
    175     void applyClip(const ClipBase* clip, const Matrix4& transform);
    176 
    177     /**
    178      * Resets the clip to the specified rect.
    179      */
    180     void resetClip(float left, float top, float right, float bottom);
    181 
    182     /**
    183      * Resets the current transform to a pure 3D translation.
    184      */
    185     void resetTransform(float x, float y, float z);
    186 
    187     void initializeViewport(int width, int height) {
    188         mViewportData.initialize(width, height);
    189         mClipAreaRoot.setViewportDimensions(width, height);
    190     }
    191 
    192     int getViewportWidth() const { return mViewportData.mWidth; }
    193     int getViewportHeight() const { return mViewportData.mHeight; }
    194     const Matrix4& getOrthoMatrix() const { return mViewportData.mOrthoMatrix; }
    195 
    196     const Vector3& getRelativeLightCenter() const { return mRelativeLightCenter; }
    197     void setRelativeLightCenter(const Vector3& lightCenter) { mRelativeLightCenter = lightCenter; }
    198 
    199     /**
    200      * Sets (and replaces) the current clipping outline
    201      *
    202      * If the current round rect clip is high priority, the incoming clip is ignored.
    203      */
    204     void setClippingRoundRect(LinearAllocator& allocator, const Rect& bounds,
    205             float radius, bool highPriority);
    206 
    207     /**
    208      * Sets (and replaces) the current projection mask
    209      */
    210     void setProjectionPathMask(LinearAllocator& allocator, const SkPath* path);
    211 
    212     /**
    213      * Indicates whether this snapshot should be ignored. A snapshot
    214      * is typically ignored if its layer is invisible or empty.
    215      */
    216     bool isIgnored() const;
    217 
    218     /**
    219      * Indicates whether the current transform has perspective components.
    220      */
    221     bool hasPerspectiveTransform() const;
    222 
    223     /**
    224      * Fills outTransform with the current, total transform to screen space,
    225      * across layer boundaries.
    226      */
    227     // TODO: remove for HWUI_NEW_OPS
    228     void buildScreenSpaceTransform(Matrix4* outTransform) const;
    229 
    230     /**
    231      * Dirty flags.
    232      */
    233     int flags;
    234 
    235     /**
    236      * Previous snapshot.
    237      */
    238     Snapshot* previous;
    239 
    240     /**
    241      * A pointer to the currently active layer.
    242      *
    243      * This snapshot does not own the layer, this pointer must not be freed.
    244      */
    245     Layer* layer;
    246 
    247     /**
    248      * Target FBO used for rendering. Set to 0 when rendering directly
    249      * into the framebuffer.
    250      */
    251     GLuint fbo;
    252 
    253     /**
    254      * Indicates that this snapshot is invisible and nothing should be drawn
    255      * inside it. This flag is set only when the layer clips drawing to its
    256      * bounds and is passed to subsequent snapshots.
    257      */
    258     bool invisible;
    259 
    260     /**
    261      * If set to true, the layer will not be composited. This is similar to
    262      * invisible but this flag is not passed to subsequent snapshots.
    263      */
    264     bool empty;
    265 
    266     /**
    267      * Local transformation. Holds the current translation, scale and
    268      * rotation values.
    269      *
    270      * This is a reference to a matrix owned by this snapshot or another
    271      *  snapshot. This pointer must not be freed. See ::mTransformRoot.
    272      */
    273     mat4* transform;
    274 
    275     /**
    276      * The ancestor layer's dirty region.
    277      *
    278      * This is a reference to a region owned by a layer. This pointer must
    279      * not be freed.
    280      */
    281     Region* region;
    282 
    283     /**
    284      * Current alpha value. This value is 1 by default, but may be set by a DisplayList which
    285      * has translucent rendering in a non-overlapping View. This value will be used by
    286      * the renderer to set the alpha in the current color being used for ensuing drawing
    287      * operations. The value is inherited by child snapshots because the same value should
    288      * be applied to descendants of the current DisplayList (for example, a TextView contains
    289      * the base alpha value which should be applied to the child DisplayLists used for drawing
    290      * the actual text).
    291      */
    292     float alpha;
    293 
    294     /**
    295      * Current clipping round rect.
    296      *
    297      * Points to data not owned by the snapshot, and may only be replaced by subsequent RR clips,
    298      * never modified.
    299      */
    300     const RoundRectClipState* roundRectClipState;
    301 
    302     /**
    303      * Current projection masking path - used exclusively to mask projected, tessellated circles.
    304      */
    305 #if HWUI_NEW_OPS
    306     const SkPath* projectionPathMask;
    307 #else
    308     const ProjectionPathMask* projectionPathMask;
    309 #endif
    310 
    311     void dump() const;
    312 
    313 private:
    314     struct ViewportData {
    315         ViewportData() : mWidth(0), mHeight(0) {}
    316         void initialize(int width, int height) {
    317             mWidth = width;
    318             mHeight = height;
    319             mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1);
    320         }
    321 
    322         /*
    323          * Width and height of current viewport.
    324          *
    325          * The viewport is always defined to be (0, 0, width, height).
    326          */
    327         int mWidth;
    328         int mHeight;
    329         /**
    330          * Contains the current orthographic, projection matrix.
    331          */
    332         mat4 mOrthoMatrix;
    333     };
    334 
    335     mat4 mTransformRoot;
    336 
    337     ClipArea mClipAreaRoot;
    338     ClipArea* mClipArea;
    339     Rect mLocalClip;
    340 
    341     ViewportData mViewportData;
    342     Vector3 mRelativeLightCenter;
    343 
    344 }; // class Snapshot
    345 
    346 }; // namespace uirenderer
    347 }; // namespace android
    348 
    349 #endif // ANDROID_HWUI_SNAPSHOT_H
    350