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