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
36namespace android {
37namespace 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 */
45class RoundRectClipState {
46public:
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
67class ProjectionPathMask {
68public:
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 */
87class Snapshot {
88public:
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
313private:
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