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