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 **/
new(size_t size,LinearAllocator & allocator)48     static void* operator new(size_t size, LinearAllocator& allocator) {
49         return allocator.alloc(size);
50     }
51 
areaRequiresRoundRectClip(const Rect & rect)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 **/
new(size_t size,LinearAllocator & allocator)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      */
getRenderTargetClip()162     const Rect& getRenderTargetClip() { return mClipArea->getClipRect(); }
163 
164     /*
165      * Accessor functions so that the clip area can stay private
166      */
clipIsEmpty()167     bool clipIsEmpty() const { return mClipArea->isEmpty(); }
getClipRect()168     const Rect& getClipRect() const { return mClipArea->getClipRect(); }
getClipRegion()169     const SkRegion& getClipRegion() const { return mClipArea->getClipRegion(); }
clipIsSimple()170     bool clipIsSimple() const { return mClipArea->isSimple(); }
getClipArea()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 
initializeViewport(int width,int height)183     void initializeViewport(int width, int height) {
184         mViewportData.initialize(width, height);
185         mClipAreaRoot.setViewportDimensions(width, height);
186     }
187 
getViewportWidth()188     int getViewportWidth() const { return mViewportData.mWidth; }
getViewportHeight()189     int getViewportHeight() const { return mViewportData.mHeight; }
getOrthoMatrix()190     const Matrix4& getOrthoMatrix() const { return mViewportData.mOrthoMatrix; }
191 
getRelativeLightCenter()192     const Vector3& getRelativeLightCenter() const { return mRelativeLightCenter; }
setRelativeLightCenter(const Vector3 & lightCenter)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 {
ViewportDataViewportData306         ViewportData() : mWidth(0), mHeight(0) {}
initializeViewportData307         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
341