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