libs/hwui/Snapshot.h

   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); PURPOSELY OMITTED, allocator only **/
  48     static void* operator new(size_t size, LinearAllocator& allocator) {
  49         return allocator.alloc(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 class ProjectionPathMask {
  67 public:
  68     /** static void* operator new(size_t size); PURPOSELY OMITTED, allocator only **/
  69     static void* operator new(size_t size, LinearAllocator& allocator) {
  70         return allocator.alloc(size);
  71     }
  72
  73     const SkPath* projectionMask;
  74     Matrix4 projectionMaskTransform;
  75 };
  76
  77 /**
  78  * A snapshot holds information about the current state of the rendering
  79  * surface. A snapshot is usually created whenever the user calls save()
  80  * and discarded when the user calls restore(). Once a snapshot is created,
  81  * it can hold information for deferred rendering.
  82  *
  83  * Each snapshot has a link to a previous snapshot, indicating the previous
  84  * state of the renderer.
  85  */
  86 class Snapshot: public LightRefBase<Snapshot> {
  87 public:
  88
  89     Snapshot();
  90     Snapshot(const sp<Snapshot>& s, int saveFlags);
  91
  92     /**
  93      * Various flags set on ::flags.
  94      */
  95     enum Flags {
  96         /**
  97          * Indicates that the clip region was modified. When this
  98          * snapshot is restored so must the clip.
  99          */
 100         kFlagClipSet = 0x1,
 101         /**
 102          * Indicates that this snapshot was created when saving
 103          * a new layer.
 104          */
 105         kFlagIsLayer = 0x2,
 106         /**
 107          * Indicates that this snapshot is a special type of layer
 108          * backed by an FBO. This flag only makes sense when the
 109          * flag kFlagIsLayer is also set.
 110          *
 111          * Viewport has been modified to fit the new Fbo, and must be
 112          * restored when this snapshot is restored.
 113          */
 114         kFlagIsFboLayer = 0x4,
 115         /**
 116          * Indicates that this snapshot or an ancestor snapshot is
 117          * an FBO layer.
 118          */
 119         kFlagFboTarget = 0x8,
 120     };
 121
 122     /**
 123      * Modifies the current clip with the new clip rectangle and
 124      * the specified operation. The specified rectangle is transformed
 125      * by this snapshot's trasnformation.
 126      */
 127     bool clip(float left, float top, float right, float bottom,
 128             SkRegion::Op op = SkRegion::kIntersect_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     bool 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     bool clipRegionTransformed(const SkRegion& region, SkRegion::Op op);
 142
 143     /**
 144      * Modifies the current clip with the specified path and operation.
 145      */
 146     bool 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() { 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 Rect& getClipRect() const { return mClipArea->getClipRect(); }
 169     const SkRegion& getClipRegion() const { return mClipArea->getClipRegion(); }
 170     bool clipIsSimple() const { return mClipArea->isSimple(); }
 171     const ClipArea& getClipArea() const { return *mClipArea; }
 172
 173     /**
 174      * Resets the clip to the specified rect.
 175      */
 176     void resetClip(float left, float top, float right, float bottom);
 177
 178     /**
 179      * Resets the current transform to a pure 3D translation.
 180      */
 181     void resetTransform(float x, float y, float z);
 182
 183     void initializeViewport(int width, int height) {
 184         mViewportData.initialize(width, height);
 185         mClipAreaRoot.setViewportDimensions(width, height);
 186     }
 187
 188     int getViewportWidth() const { return mViewportData.mWidth; }
 189     int getViewportHeight() const { return mViewportData.mHeight; }
 190     const Matrix4& getOrthoMatrix() const { return mViewportData.mOrthoMatrix; }
 191
 192     const Vector3& getRelativeLightCenter() const { return mRelativeLightCenter; }
 193     void setRelativeLightCenter(const Vector3& lightCenter) { mRelativeLightCenter = lightCenter; }
 194
 195     /**
 196      * Sets (and replaces) the current clipping outline
 197      *
 198      * If the current round rect clip is high priority, the incoming clip is ignored.
 199      */
 200     void setClippingRoundRect(LinearAllocator& allocator, const Rect& bounds,
 201             float radius, bool highPriority);
 202
 203     /**
 204      * Sets (and replaces) the current projection mask
 205      */
 206     void setProjectionPathMask(LinearAllocator& allocator, const SkPath* path);
 207
 208     /**
 209      * Indicates whether this snapshot should be ignored. A snapshot
 210      * is typically ignored if its layer is invisible or empty.
 211      */
 212     bool isIgnored() const;
 213
 214     /**
 215      * Indicates whether the current transform has perspective components.
 216      */
 217     bool hasPerspectiveTransform() const;
 218
 219     /**
 220      * Fills outTransform with the current, total transform to screen space,
 221      * across layer boundaries.
 222      */
 223     void buildScreenSpaceTransform(Matrix4* outTransform) const;
 224
 225     /**
 226      * Dirty flags.
 227      */
 228     int flags;
 229
 230     /**
 231      * Previous snapshot.
 232      */
 233     sp<Snapshot> previous;
 234
 235     /**
 236      * A pointer to the currently active layer.
 237      *
 238      * This snapshot does not own the layer, this pointer must not be freed.
 239      */
 240     Layer* layer;
 241
 242     /**
 243      * Target FBO used for rendering. Set to 0 when rendering directly
 244      * into the framebuffer.
 245      */
 246     GLuint fbo;
 247
 248     /**
 249      * Indicates that this snapshot is invisible and nothing should be drawn
 250      * inside it. This flag is set only when the layer clips drawing to its
 251      * bounds and is passed to subsequent snapshots.
 252      */
 253     bool invisible;
 254
 255     /**
 256      * If set to true, the layer will not be composited. This is similar to
 257      * invisible but this flag is not passed to subsequent snapshots.
 258      */
 259     bool empty;
 260
 261     /**
 262      * Local transformation. Holds the current translation, scale and
 263      * rotation values.
 264      *
 265      * This is a reference to a matrix owned by this snapshot or another
 266      *  snapshot. This pointer must not be freed. See ::mTransformRoot.
 267      */
 268     mat4* transform;
 269
 270     /**
 271      * The ancestor layer's dirty region.
 272      *
 273      * This is a reference to a region owned by a layer. This pointer must
 274      * not be freed.
 275      */
 276     Region* region;
 277
 278     /**
 279      * Current alpha value. This value is 1 by default, but may be set by a DisplayList which
 280      * has translucent rendering in a non-overlapping View. This value will be used by
 281      * the renderer to set the alpha in the current color being used for ensuing drawing
 282      * operations. The value is inherited by child snapshots because the same value should
 283      * be applied to descendants of the current DisplayList (for example, a TextView contains
 284      * the base alpha value which should be applied to the child DisplayLists used for drawing
 285      * the actual text).
 286      */
 287     float alpha;
 288
 289     /**
 290      * Current clipping round rect.
 291      *
 292      * Points to data not owned by the snapshot, and may only be replaced by subsequent RR clips,
 293      * never modified.
 294      */
 295     const RoundRectClipState* roundRectClipState;
 296
 297     /**
 298      * Current projection masking path - used exclusively to mask tessellated circles.
 299      */
 300     const ProjectionPathMask* projectionPathMask;
 301
 302     void dump() const;
 303
 304 private:
 305     struct ViewportData {
 306         ViewportData() : mWidth(0), mHeight(0) {}
 307         void initialize(int width, int height) {
 308             mWidth = width;
 309             mHeight = height;
 310             mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1);
 311         }
 312
 313         /*
 314          * Width and height of current viewport.
 315          *
 316          * The viewport is always defined to be (0, 0, width, height).
 317          */
 318         int mWidth;
 319         int mHeight;
 320         /**
 321          * Contains the current orthographic, projection matrix.
 322          */
 323         mat4 mOrthoMatrix;
 324     };
 325
 326     mat4 mTransformRoot;
 327
 328     ClipArea mClipAreaRoot;
 329     ClipArea* mClipArea;
 330     Rect mLocalClip;
 331
 332     ViewportData mViewportData;
 333     Vector3 mRelativeLightCenter;
 334
 335 }; // class Snapshot
 336
 337 }; // namespace uirenderer
 338 }; // namespace android
 339
 340 #endif // ANDROID_HWUI_SNAPSHOT_H