LayerRenderer.cpp revision a9dc86b21defc26db0d71f276aff5c3af0b62ff5
1/* 2 * Copyright (C) 2011 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#define LOG_TAG "OpenGLRenderer" 18 19#include <ui/Rect.h> 20 21#include "LayerCache.h" 22#include "LayerRenderer.h" 23#include "Matrix.h" 24#include "Properties.h" 25#include "Rect.h" 26 27namespace android { 28namespace uirenderer { 29 30/////////////////////////////////////////////////////////////////////////////// 31// Rendering 32/////////////////////////////////////////////////////////////////////////////// 33 34void LayerRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) { 35 LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->getFbo()); 36 37 glBindFramebuffer(GL_FRAMEBUFFER, mLayer->getFbo()); 38 39 const float width = mLayer->layer.getWidth(); 40 const float height = mLayer->layer.getHeight(); 41 42#if RENDER_LAYERS_AS_REGIONS 43 Rect dirty(left, top, right, bottom); 44 if (dirty.isEmpty() || (dirty.left <= 0 && dirty.top <= 0 && 45 dirty.right >= width && dirty.bottom >= height)) { 46 mLayer->region.clear(); 47 dirty.set(0.0f, 0.0f, width, height); 48 } else { 49 dirty.intersect(0.0f, 0.0f, width, height); 50 android::Rect r(dirty.left, dirty.top, dirty.right, dirty.bottom); 51 mLayer->region.subtractSelf(r); 52 } 53 54 OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque); 55#else 56 OpenGLRenderer::prepareDirty(0.0f, 0.0f, width, height, opaque); 57#endif 58} 59 60void LayerRenderer::finish() { 61 OpenGLRenderer::finish(); 62 63 generateMesh(); 64 65 LAYER_RENDERER_LOGD("Finished rendering into layer, fbo = %d", mLayer->getFbo()); 66 67 // No need to unbind our FBO, this will be taken care of by the caller 68 // who will invoke OpenGLRenderer::resume() 69} 70 71GLint LayerRenderer::getTargetFbo() { 72 return mLayer->getFbo(); 73} 74 75/////////////////////////////////////////////////////////////////////////////// 76// Dirty region tracking 77/////////////////////////////////////////////////////////////////////////////// 78 79bool LayerRenderer::hasLayer() { 80 return true; 81} 82 83Region* LayerRenderer::getRegion() { 84#if RENDER_LAYERS_AS_REGIONS 85 if (getSnapshot()->flags & Snapshot::kFlagFboTarget) { 86 return OpenGLRenderer::getRegion(); 87 } 88 return &mLayer->region; 89#else 90 return OpenGLRenderer::getRegion(); 91#endif 92} 93 94// TODO: This implementation is flawed and can generate T-junctions 95// in the mesh, which will in turn produce cracks when the 96// mesh is rotated/skewed. The easiest way to fix this would 97// be, for each row, to add new vertices shared with the previous 98// row when the two rows share an edge. 99// In practice, T-junctions do not appear often so this has yet 100// to be fixed. 101void LayerRenderer::generateMesh() { 102#if RENDER_LAYERS_AS_REGIONS 103 if (mLayer->region.isRect() || mLayer->region.isEmpty()) { 104 if (mLayer->mesh) { 105 delete mLayer->mesh; 106 delete mLayer->meshIndices; 107 108 mLayer->mesh = NULL; 109 mLayer->meshIndices = NULL; 110 mLayer->meshElementCount = 0; 111 } 112 113 mLayer->setRegionAsRect(); 114 return; 115 } 116 117 size_t count; 118 const android::Rect* rects = mLayer->region.getArray(&count); 119 120 GLsizei elementCount = count * 6; 121 122 if (mLayer->mesh && mLayer->meshElementCount < elementCount) { 123 delete mLayer->mesh; 124 delete mLayer->meshIndices; 125 126 mLayer->mesh = NULL; 127 mLayer->meshIndices = NULL; 128 } 129 130 bool rebuildIndices = false; 131 if (!mLayer->mesh) { 132 mLayer->mesh = new TextureVertex[count * 4]; 133 mLayer->meshIndices = new uint16_t[elementCount]; 134 rebuildIndices = true; 135 } 136 mLayer->meshElementCount = elementCount; 137 138 const float texX = 1.0f / float(mLayer->getWidth()); 139 const float texY = 1.0f / float(mLayer->getHeight()); 140 const float height = mLayer->layer.getHeight(); 141 142 TextureVertex* mesh = mLayer->mesh; 143 uint16_t* indices = mLayer->meshIndices; 144 145 for (size_t i = 0; i < count; i++) { 146 const android::Rect* r = &rects[i]; 147 148 const float u1 = r->left * texX; 149 const float v1 = (height - r->top) * texY; 150 const float u2 = r->right * texX; 151 const float v2 = (height - r->bottom) * texY; 152 153 TextureVertex::set(mesh++, r->left, r->top, u1, v1); 154 TextureVertex::set(mesh++, r->right, r->top, u2, v1); 155 TextureVertex::set(mesh++, r->left, r->bottom, u1, v2); 156 TextureVertex::set(mesh++, r->right, r->bottom, u2, v2); 157 158 if (rebuildIndices) { 159 uint16_t quad = i * 4; 160 int index = i * 6; 161 indices[index ] = quad; // top-left 162 indices[index + 1] = quad + 1; // top-right 163 indices[index + 2] = quad + 2; // bottom-left 164 indices[index + 3] = quad + 2; // bottom-left 165 indices[index + 4] = quad + 1; // top-right 166 indices[index + 5] = quad + 3; // bottom-right 167 } 168 } 169#endif 170} 171 172/////////////////////////////////////////////////////////////////////////////// 173// Layers management 174/////////////////////////////////////////////////////////////////////////////// 175 176Layer* LayerRenderer::createLayer(uint32_t width, uint32_t height, bool isOpaque) { 177 LAYER_RENDERER_LOGD("Requesting new render layer %dx%d", width, height); 178 179 GLuint fbo = Caches::getInstance().fboCache.get(); 180 if (!fbo) { 181 LOGW("Could not obtain an FBO"); 182 return NULL; 183 } 184 185 glActiveTexture(GL_TEXTURE0); 186 Layer* layer = Caches::getInstance().layerCache.get(width, height); 187 if (!layer) { 188 LOGW("Could not obtain a layer"); 189 return NULL; 190 } 191 192 layer->setFbo(fbo); 193 layer->layer.set(0.0f, 0.0f, width, height); 194 layer->texCoords.set(0.0f, height / float(layer->getHeight()), 195 width / float(layer->getWidth()), 0.0f); 196 layer->setAlpha(255, SkXfermode::kSrcOver_Mode); 197 layer->setBlend(!isOpaque); 198 layer->setColorFilter(NULL); 199 layer->region.clear(); 200 201 GLuint previousFbo; 202 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo); 203 204 glBindFramebuffer(GL_FRAMEBUFFER, layer->getFbo()); 205 layer->bindTexture(); 206 207 // Initialize the texture if needed 208 if (layer->isEmpty()) { 209 layer->setEmpty(false); 210 layer->allocateTexture(GL_RGBA, GL_UNSIGNED_BYTE); 211 212 if (glGetError() != GL_NO_ERROR) { 213 LOGD("Could not allocate texture"); 214 215 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo); 216 Caches::getInstance().fboCache.put(fbo); 217 218 layer->deleteTexture(); 219 delete layer; 220 221 return NULL; 222 } 223 } 224 225 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 226 layer->getTexture(), 0); 227 228 glDisable(GL_SCISSOR_TEST); 229 glClearColor(0.0f, 0.0f, 0.0f, 0.0f); 230 glClear(GL_COLOR_BUFFER_BIT); 231 glEnable(GL_SCISSOR_TEST); 232 233 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo); 234 235 return layer; 236} 237 238bool LayerRenderer::resizeLayer(Layer* layer, uint32_t width, uint32_t height) { 239 if (layer) { 240 LAYER_RENDERER_LOGD("Resizing layer fbo = %d to %dx%d", layer->getFbo(), width, height); 241 242 if (Caches::getInstance().layerCache.resize(layer, width, height)) { 243 layer->layer.set(0.0f, 0.0f, width, height); 244 layer->texCoords.set(0.0f, height / float(layer->getHeight()), 245 width / float(layer->getWidth()), 0.0f); 246 } else { 247 layer->deleteTexture(); 248 delete layer; 249 return false; 250 } 251 } 252 253 return true; 254} 255 256Layer* LayerRenderer::createTextureLayer(bool isOpaque) { 257 LAYER_RENDERER_LOGD("Creating new texture layer"); 258 259 Layer* layer = new Layer(0, 0); 260 layer->setCacheable(false); 261 layer->setTextureLayer(true); 262 layer->setBlend(!isOpaque); 263 layer->setEmpty(true); 264 layer->setFbo(0); 265 layer->setAlpha(255, SkXfermode::kSrcOver_Mode); 266 layer->layer.set(0.0f, 0.0f, 0.0f, 0.0f); 267 layer->texCoords.set(0.0f, 1.0f, 1.0f, 0.0f); 268 layer->region.clear(); 269 layer->setRenderTarget(GL_NONE); // see ::updateTextureLayer() 270 271 glActiveTexture(GL_TEXTURE0); 272 layer->generateTexture(); 273 274 return layer; 275} 276 277void LayerRenderer::updateTextureLayer(Layer* layer, uint32_t width, uint32_t height, 278 bool isOpaque, GLenum renderTarget, float* transform) { 279 if (layer) { 280 layer->setBlend(!isOpaque); 281 layer->setSize(width, height); 282 layer->layer.set(0.0f, 0.0f, width, height); 283 layer->region.set(width, height); 284 layer->regionRect.set(0.0f, 0.0f, width, height); 285 layer->getTexTransform().load(transform); 286 287 if (renderTarget != layer->getRenderTarget()) { 288 layer->setRenderTarget(renderTarget); 289 layer->bindTexture(); 290 layer->setFilter(GL_NEAREST, GL_NEAREST, false, true); 291 layer->setWrap(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, false, true); 292 } 293 } 294} 295 296void LayerRenderer::destroyLayer(Layer* layer) { 297 if (layer) { 298 LAYER_RENDERER_LOGD("Recycling layer, %dx%d fbo = %d", 299 layer->getWidth(), layer->getHeight(), layer->getFbo()); 300 301 if (layer->getFbo()) { 302 Caches::getInstance().fboCache.put(layer->getFbo()); 303 } 304 305 if (!Caches::getInstance().layerCache.put(layer)) { 306 LAYER_RENDERER_LOGD(" Destroyed!"); 307 layer->deleteTexture(); 308 delete layer; 309 } else { 310 LAYER_RENDERER_LOGD(" Cached!"); 311#if DEBUG_LAYER_RENDERER 312 Caches::getInstance().layerCache.dump(); 313#endif 314 layer->region.clear(); 315 } 316 } 317} 318 319void LayerRenderer::destroyLayerDeferred(Layer* layer) { 320 if (layer) { 321 LAYER_RENDERER_LOGD("Deferring layer destruction, fbo = %d", layer->getFbo()); 322 323 Caches::getInstance().deleteLayerDeferred(layer); 324 } 325} 326 327bool LayerRenderer::copyLayer(Layer* layer, SkBitmap* bitmap) { 328 Caches& caches = Caches::getInstance(); 329 if (layer && layer->isTextureLayer() && bitmap->width() <= caches.maxTextureSize && 330 bitmap->height() <= caches.maxTextureSize) { 331 332 GLuint fbo = caches.fboCache.get(); 333 if (!fbo) { 334 LOGW("Could not obtain an FBO"); 335 return false; 336 } 337 338 SkAutoLockPixels alp(*bitmap); 339 340 GLuint texture; 341 GLuint previousFbo; 342 343 GLenum format; 344 GLenum type; 345 346 GLenum error = GL_NO_ERROR; 347 bool status = false; 348 349 switch (bitmap->config()) { 350 case SkBitmap::kA8_Config: 351 format = GL_ALPHA; 352 type = GL_UNSIGNED_BYTE; 353 break; 354 case SkBitmap::kRGB_565_Config: 355 format = GL_RGB; 356 type = GL_UNSIGNED_SHORT_5_6_5; 357 break; 358 case SkBitmap::kARGB_4444_Config: 359 format = GL_RGBA; 360 type = GL_UNSIGNED_SHORT_4_4_4_4; 361 break; 362 case SkBitmap::kARGB_8888_Config: 363 default: 364 format = GL_RGBA; 365 type = GL_UNSIGNED_BYTE; 366 break; 367 } 368 369 float alpha = layer->getAlpha(); 370 SkXfermode::Mode mode = layer->getMode(); 371 372 layer->setAlpha(255, SkXfermode::kSrc_Mode); 373 layer->setFbo(fbo); 374 375 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo); 376 glBindFramebuffer(GL_FRAMEBUFFER, fbo); 377 378 glGenTextures(1, &texture); 379 if ((error = glGetError()) != GL_NO_ERROR) goto error; 380 381 glActiveTexture(GL_TEXTURE0); 382 glBindTexture(GL_TEXTURE_2D, texture); 383 384 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 385 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 386 387 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 388 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 389 390 glTexImage2D(GL_TEXTURE_2D, 0, format, bitmap->width(), bitmap->height(), 391 0, format, type, NULL); 392 if ((error = glGetError()) != GL_NO_ERROR) goto error; 393 394 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 395 GL_TEXTURE_2D, texture, 0); 396 if ((error = glGetError()) != GL_NO_ERROR) goto error; 397 398 { 399 LayerRenderer renderer(layer); 400 renderer.setViewport(bitmap->width(), bitmap->height()); 401 renderer.OpenGLRenderer::prepareDirty(0.0f, 0.0f, 402 bitmap->width(), bitmap->height(), !layer->isBlend()); 403 404 glDisable(GL_SCISSOR_TEST); 405 renderer.translate(0.0f, bitmap->height()); 406 renderer.scale(1.0f, -1.0f); 407 408 mat4 texTransform(layer->getTexTransform()); 409 410 mat4 invert; 411 invert.translate(0.0f, 1.0f, 0.0f); 412 invert.scale(1.0f, -1.0f, 1.0f); 413 layer->getTexTransform().multiply(invert); 414 415 if ((error = glGetError()) != GL_NO_ERROR) goto error; 416 417 { 418 Rect bounds; 419 bounds.set(0.0f, 0.0f, bitmap->width(), bitmap->height()); 420 renderer.drawTextureLayer(layer, bounds); 421 422 glReadPixels(0, 0, bitmap->width(), bitmap->height(), format, 423 type, bitmap->getPixels()); 424 425 if ((error = glGetError()) != GL_NO_ERROR) goto error; 426 } 427 428 layer->getTexTransform().load(texTransform); 429 status = true; 430 } 431 432error: 433#if DEBUG_OPENGL 434 if (error != GL_NO_ERROR) { 435 LOGD("GL error while copying layer into bitmap = 0x%x", error); 436 } 437#endif 438 439 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo); 440 layer->setAlpha(alpha, mode); 441 layer->setFbo(0); 442 glDeleteTextures(1, &texture); 443 caches.fboCache.put(fbo); 444 445 return status; 446 } 447 return false; 448} 449 450}; // namespace uirenderer 451}; // namespace android 452