• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_LAYER_H
18 #define ANDROID_HWUI_LAYER_H
19 
20 #include <sys/types.h>
21 
22 #include <GLES2/gl2.h>
23 
24 #include <ui/Region.h>
25 
26 #include <SkPaint.h>
27 #include <SkXfermode.h>
28 
29 #include "Rect.h"
30 #include "RenderBuffer.h"
31 #include "SkiaColorFilter.h"
32 #include "Texture.h"
33 #include "Vertex.h"
34 
35 namespace android {
36 namespace uirenderer {
37 
38 ///////////////////////////////////////////////////////////////////////////////
39 // Layers
40 ///////////////////////////////////////////////////////////////////////////////
41 
42 // Forward declarations
43 class Caches;
44 class OpenGLRenderer;
45 class DisplayList;
46 class DeferredDisplayList;
47 class DeferStateStruct;
48 
49 /**
50  * A layer has dimensions and is backed by an OpenGL texture or FBO.
51  */
52 struct Layer {
53     Layer(const uint32_t layerWidth, const uint32_t layerHeight);
54     ~Layer();
55 
56     static uint32_t computeIdealWidth(uint32_t layerWidth);
57     static uint32_t computeIdealHeight(uint32_t layerHeight);
58 
59     /**
60      * Calling this method will remove (either by recycling or
61      * destroying) the associated FBO, if present, and any render
62      * buffer (stencil for instance.)
63      */
64     void removeFbo(bool flush = true);
65 
66     /**
67      * Sets this layer's region to a rectangle. Computes the appropriate
68      * texture coordinates.
69      */
setRegionAsRectLayer70     void setRegionAsRect() {
71         const android::Rect& bounds = region.getBounds();
72         regionRect.set(bounds.leftTop().x, bounds.leftTop().y,
73                bounds.rightBottom().x, bounds.rightBottom().y);
74 
75         const float texX = 1.0f / float(texture.width);
76         const float texY = 1.0f / float(texture.height);
77         const float height = layer.getHeight();
78         texCoords.set(
79                regionRect.left * texX, (height - regionRect.top) * texY,
80                regionRect.right * texX, (height - regionRect.bottom) * texY);
81 
82         regionRect.translate(layer.left, layer.top);
83     }
84 
updateDeferredLayer85     void updateDeferred(OpenGLRenderer* renderer, DisplayList* displayList,
86             int left, int top, int right, int bottom) {
87         this->renderer = renderer;
88         this->displayList = displayList;
89         const Rect r(left, top, right, bottom);
90         dirtyRect.unionWith(r);
91         deferredUpdateScheduled = true;
92     }
93 
getWidthLayer94     inline uint32_t getWidth() const {
95         return texture.width;
96     }
97 
getHeightLayer98     inline uint32_t getHeight() const {
99         return texture.height;
100     }
101 
102     /**
103      * Resize the layer and its texture if needed.
104      *
105      * @param width The new width of the layer
106      * @param height The new height of the layer
107      *
108      * @return True if the layer was resized or nothing happened, false if
109      *         a failure occurred during the resizing operation
110      */
111     bool resize(const uint32_t width, const uint32_t height);
112 
setSizeLayer113     void setSize(uint32_t width, uint32_t height) {
114         texture.width = width;
115         texture.height = height;
116     }
117 
118     ANDROID_API void setPaint(SkPaint* paint);
119 
setBlendLayer120     inline void setBlend(bool blend) {
121         texture.blend = blend;
122     }
123 
isBlendLayer124     inline bool isBlend() const {
125         return texture.blend;
126     }
127 
setAlphaLayer128     inline void setAlpha(int alpha) {
129         this->alpha = alpha;
130     }
131 
setAlphaLayer132     inline void setAlpha(int alpha, SkXfermode::Mode mode) {
133         this->alpha = alpha;
134         this->mode = mode;
135     }
136 
getAlphaLayer137     inline int getAlpha() const {
138         return alpha;
139     }
140 
getModeLayer141     inline SkXfermode::Mode getMode() const {
142         return mode;
143     }
144 
setEmptyLayer145     inline void setEmpty(bool empty) {
146         this->empty = empty;
147     }
148 
isEmptyLayer149     inline bool isEmpty() const {
150         return empty;
151     }
152 
setFboLayer153     inline void setFbo(GLuint fbo) {
154         this->fbo = fbo;
155     }
156 
getFboLayer157     inline GLuint getFbo() const {
158         return fbo;
159     }
160 
setStencilRenderBufferLayer161     inline void setStencilRenderBuffer(RenderBuffer* renderBuffer) {
162         if (RenderBuffer::isStencilBuffer(renderBuffer->getFormat())) {
163             this->stencil = renderBuffer;
164             glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
165                     GL_RENDERBUFFER, stencil->getName());
166         } else {
167             ALOGE("The specified render buffer is not a stencil buffer");
168         }
169     }
170 
getStencilRenderBufferLayer171     inline RenderBuffer* getStencilRenderBuffer() const {
172         return stencil;
173     }
174 
getTextureLayer175     inline GLuint getTexture() const {
176         return texture.id;
177     }
178 
getRenderTargetLayer179     inline GLenum getRenderTarget() const {
180         return renderTarget;
181     }
182 
setRenderTargetLayer183     inline void setRenderTarget(GLenum renderTarget) {
184         this->renderTarget = renderTarget;
185     }
186 
187     void setWrap(GLenum wrap, bool bindTexture = false, bool force = false) {
188         texture.setWrap(wrap, bindTexture, force, renderTarget);
189     }
190 
191     void setFilter(GLenum filter, bool bindTexture = false, bool force = false) {
192         texture.setFilter(filter, bindTexture, force, renderTarget);
193     }
194 
isCacheableLayer195     inline bool isCacheable() const {
196         return cacheable;
197     }
198 
setCacheableLayer199     inline void setCacheable(bool cacheable) {
200         this->cacheable = cacheable;
201     }
202 
isDirtyLayer203     inline bool isDirty() const {
204         return dirty;
205     }
206 
setDirtyLayer207     inline void setDirty(bool dirty) {
208         this->dirty = dirty;
209     }
210 
isTextureLayerLayer211     inline bool isTextureLayer() const {
212         return textureLayer;
213     }
214 
setTextureLayerLayer215     inline void setTextureLayer(bool textureLayer) {
216         this->textureLayer = textureLayer;
217     }
218 
getColorFilterLayer219     inline SkiaColorFilter* getColorFilter() const {
220         return colorFilter;
221     }
222 
223     ANDROID_API void setColorFilter(SkiaColorFilter* filter);
224 
225     void bindStencilRenderBuffer() const;
226 
227     void bindTexture() const;
228     void generateTexture();
229     void allocateTexture();
230     void deleteTexture();
231 
232     /**
233      * When the caller frees the texture itself, the caller
234      * must call this method to tell this layer that it lost
235      * the texture.
236      */
237     ANDROID_API void clearTexture();
238 
getTexTransformLayer239     inline mat4& getTexTransform() {
240         return texTransform;
241     }
242 
getTransformLayer243     inline mat4& getTransform() {
244         return transform;
245     }
246 
247     void defer();
248     void cancelDefer();
249     void flush();
250     void render();
251 
252     /**
253      * Bounds of the layer.
254      */
255     Rect layer;
256     /**
257      * Texture coordinates of the layer.
258      */
259     Rect texCoords;
260     /**
261      * Clipping rectangle.
262      */
263     Rect clipRect;
264 
265     /**
266      * Dirty region indicating what parts of the layer
267      * have been drawn.
268      */
269     Region region;
270     /**
271      * If the region is a rectangle, coordinates of the
272      * region are stored here.
273      */
274     Rect regionRect;
275 
276     /**
277      * If the layer can be rendered as a mesh, this is non-null.
278      */
279     TextureVertex* mesh;
280     GLsizei meshElementCount;
281 
282     /**
283      * Used for deferred updates.
284      */
285     bool deferredUpdateScheduled;
286     OpenGLRenderer* renderer;
287     DisplayList* displayList;
288     Rect dirtyRect;
289     bool debugDrawUpdate;
290     bool hasDrawnSinceUpdate;
291 
292 private:
293     Caches& caches;
294 
295     /**
296      * Name of the FBO used to render the layer. If the name is 0
297      * this layer is not backed by an FBO, but a simple texture.
298      */
299     GLuint fbo;
300 
301     /**
302      * The render buffer used as the stencil buffer.
303      */
304     RenderBuffer* stencil;
305 
306     /**
307      * Indicates whether this layer has been used already.
308      */
309     bool empty;
310 
311     /**
312      * The texture backing this layer.
313      */
314     Texture texture;
315 
316     /**
317      * If set to true (by default), the layer can be reused.
318      */
319     bool cacheable;
320 
321     /**
322      * When set to true, this layer must be treated as a texture
323      * layer.
324      */
325     bool textureLayer;
326 
327     /**
328      * When set to true, this layer is dirty and should be cleared
329      * before any rendering occurs.
330      */
331     bool dirty;
332 
333     /**
334      * Indicates the render target.
335      */
336     GLenum renderTarget;
337 
338     /**
339      * Color filter used to draw this layer. Optional.
340      */
341     SkiaColorFilter* colorFilter;
342 
343     /**
344      * Opacity of the layer.
345      */
346     int alpha;
347     /**
348      * Blending mode of the layer.
349      */
350     SkXfermode::Mode mode;
351 
352     /**
353      * Optional texture coordinates transform.
354      */
355     mat4 texTransform;
356 
357     /**
358      * Optional transform.
359      */
360     mat4 transform;
361 
362     /**
363      * Used to defer display lists when the layer is updated with a
364      * display list.
365      */
366     DeferredDisplayList* deferredList;
367 
368 }; // struct Layer
369 
370 }; // namespace uirenderer
371 }; // namespace android
372 
373 #endif // ANDROID_HWUI_LAYER_H
374