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