blob: 6bf60046021b3b9a341d7eeeea80abe77e07b551 [file] [log] [blame]
Romain Guy6c319ca2011-01-11 14:29:25 -08001/*
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
Romain Guy3a3133d2011-02-01 22:59:58 -080019#include <ui/Rect.h>
20
Romain Guy09b7c912011-02-02 20:28:09 -080021#include "LayerCache.h"
Romain Guy6c319ca2011-01-11 14:29:25 -080022#include "LayerRenderer.h"
Romain Guyaa6c24c2011-04-28 18:40:04 -070023#include "Matrix.h"
Romain Guy1fc883b2011-01-12 14:30:59 -080024#include "Properties.h"
Romain Guy3a3133d2011-02-01 22:59:58 -080025#include "Rect.h"
Romain Guy6c319ca2011-01-11 14:29:25 -080026
27namespace android {
28namespace uirenderer {
29
30///////////////////////////////////////////////////////////////////////////////
31// Rendering
32///////////////////////////////////////////////////////////////////////////////
33
Romain Guy79537452011-10-12 13:48:51 -070034LayerRenderer::LayerRenderer(Layer* layer): mLayer(layer) {
35}
36
37LayerRenderer::~LayerRenderer() {
38}
39
Romain Guy7d7b5492011-01-24 16:33:45 -080040void LayerRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) {
Romain Guy9ace8f52011-07-07 20:50:11 -070041 LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->getFbo());
Romain Guy1fc883b2011-01-12 14:30:59 -080042
Romain Guy9ace8f52011-07-07 20:50:11 -070043 glBindFramebuffer(GL_FRAMEBUFFER, mLayer->getFbo());
Romain Guy62687ec2011-02-02 15:44:19 -080044
Romain Guy09b7c912011-02-02 20:28:09 -080045 const float width = mLayer->layer.getWidth();
46 const float height = mLayer->layer.getHeight();
47
Romain Guyc88e3572011-01-22 00:32:12 -080048#if RENDER_LAYERS_AS_REGIONS
Romain Guy3a3133d2011-02-01 22:59:58 -080049 Rect dirty(left, top, right, bottom);
50 if (dirty.isEmpty() || (dirty.left <= 0 && dirty.top <= 0 &&
Romain Guy09b7c912011-02-02 20:28:09 -080051 dirty.right >= width && dirty.bottom >= height)) {
Romain Guy3a3133d2011-02-01 22:59:58 -080052 mLayer->region.clear();
Romain Guy09b7c912011-02-02 20:28:09 -080053 dirty.set(0.0f, 0.0f, width, height);
Romain Guy3a3133d2011-02-01 22:59:58 -080054 } else {
Romain Guy09b7c912011-02-02 20:28:09 -080055 dirty.intersect(0.0f, 0.0f, width, height);
Romain Guy3a3133d2011-02-01 22:59:58 -080056 android::Rect r(dirty.left, dirty.top, dirty.right, dirty.bottom);
57 mLayer->region.subtractSelf(r);
58 }
Romain Guyc88e3572011-01-22 00:32:12 -080059
Romain Guy3a3133d2011-02-01 22:59:58 -080060 OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);
61#else
Romain Guy09b7c912011-02-02 20:28:09 -080062 OpenGLRenderer::prepareDirty(0.0f, 0.0f, width, height, opaque);
Romain Guy3a3133d2011-02-01 22:59:58 -080063#endif
Romain Guy6c319ca2011-01-11 14:29:25 -080064}
65
66void LayerRenderer::finish() {
67 OpenGLRenderer::finish();
Romain Guy1fc883b2011-01-12 14:30:59 -080068
Romain Guyf219da52011-01-16 12:54:25 -080069 generateMesh();
70
Romain Guy9ace8f52011-07-07 20:50:11 -070071 LAYER_RENDERER_LOGD("Finished rendering into layer, fbo = %d", mLayer->getFbo());
Romain Guy42f3a4b2011-01-19 13:42:26 -080072
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() {
Romain Guy9ace8f52011-07-07 20:50:11 -070078 return mLayer->getFbo();
Romain Guy6c319ca2011-01-11 14:29:25 -080079}
80
81///////////////////////////////////////////////////////////////////////////////
Romain Guyf219da52011-01-16 12:54:25 -080082// Dirty region tracking
83///////////////////////////////////////////////////////////////////////////////
84
85bool LayerRenderer::hasLayer() {
86 return true;
87}
88
89Region* LayerRenderer::getRegion() {
90#if RENDER_LAYERS_AS_REGIONS
91 if (getSnapshot()->flags & Snapshot::kFlagFboTarget) {
92 return OpenGLRenderer::getRegion();
93 }
94 return &mLayer->region;
95#else
96 return OpenGLRenderer::getRegion();
97#endif
98}
99
Romain Guy8a3957d2011-09-07 17:55:15 -0700100// 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.
Romain Guyf219da52011-01-16 12:54:25 -0800107void LayerRenderer::generateMesh() {
108#if RENDER_LAYERS_AS_REGIONS
109 if (mLayer->region.isRect() || mLayer->region.isEmpty()) {
110 if (mLayer->mesh) {
111 delete mLayer->mesh;
112 delete mLayer->meshIndices;
113
114 mLayer->mesh = NULL;
115 mLayer->meshIndices = NULL;
116 mLayer->meshElementCount = 0;
117 }
Romain Guy40667672011-03-18 14:34:03 -0700118
Romain Guy9fc27812011-04-27 14:21:41 -0700119 mLayer->setRegionAsRect();
Romain Guyf219da52011-01-16 12:54:25 -0800120 return;
121 }
122
123 size_t count;
124 const android::Rect* rects = mLayer->region.getArray(&count);
125
126 GLsizei elementCount = count * 6;
127
128 if (mLayer->mesh && mLayer->meshElementCount < elementCount) {
129 delete mLayer->mesh;
130 delete mLayer->meshIndices;
131
132 mLayer->mesh = NULL;
133 mLayer->meshIndices = NULL;
134 }
135
Romain Guy4f09f542011-01-26 22:41:43 -0800136 bool rebuildIndices = false;
Romain Guyf219da52011-01-16 12:54:25 -0800137 if (!mLayer->mesh) {
138 mLayer->mesh = new TextureVertex[count * 4];
139 mLayer->meshIndices = new uint16_t[elementCount];
Romain Guy4f09f542011-01-26 22:41:43 -0800140 rebuildIndices = true;
Romain Guyf219da52011-01-16 12:54:25 -0800141 }
Romain Guy4f09f542011-01-26 22:41:43 -0800142 mLayer->meshElementCount = elementCount;
Romain Guyf219da52011-01-16 12:54:25 -0800143
Romain Guy9ace8f52011-07-07 20:50:11 -0700144 const float texX = 1.0f / float(mLayer->getWidth());
145 const float texY = 1.0f / float(mLayer->getHeight());
Romain Guyf219da52011-01-16 12:54:25 -0800146 const float height = mLayer->layer.getHeight();
147
148 TextureVertex* mesh = mLayer->mesh;
149 uint16_t* indices = mLayer->meshIndices;
150
151 for (size_t i = 0; i < count; i++) {
152 const android::Rect* r = &rects[i];
153
154 const float u1 = r->left * texX;
155 const float v1 = (height - r->top) * texY;
156 const float u2 = r->right * texX;
157 const float v2 = (height - r->bottom) * texY;
158
159 TextureVertex::set(mesh++, r->left, r->top, u1, v1);
160 TextureVertex::set(mesh++, r->right, r->top, u2, v1);
161 TextureVertex::set(mesh++, r->left, r->bottom, u1, v2);
162 TextureVertex::set(mesh++, r->right, r->bottom, u2, v2);
163
Romain Guy4f09f542011-01-26 22:41:43 -0800164 if (rebuildIndices) {
165 uint16_t quad = i * 4;
166 int index = i * 6;
167 indices[index ] = quad; // top-left
168 indices[index + 1] = quad + 1; // top-right
169 indices[index + 2] = quad + 2; // bottom-left
170 indices[index + 3] = quad + 2; // bottom-left
171 indices[index + 4] = quad + 1; // top-right
172 indices[index + 5] = quad + 3; // bottom-right
173 }
Romain Guyf219da52011-01-16 12:54:25 -0800174 }
175#endif
176}
177
178///////////////////////////////////////////////////////////////////////////////
179// Layers management
Romain Guy6c319ca2011-01-11 14:29:25 -0800180///////////////////////////////////////////////////////////////////////////////
181
Romain Guyada830f2011-01-13 12:13:20 -0800182Layer* LayerRenderer::createLayer(uint32_t width, uint32_t height, bool isOpaque) {
Romain Guyeea60692011-07-26 20:35:55 -0700183 LAYER_RENDERER_LOGD("Requesting new render layer %dx%d", width, height);
Romain Guy1fc883b2011-01-12 14:30:59 -0800184
Romain Guy09b7c912011-02-02 20:28:09 -0800185 GLuint fbo = Caches::getInstance().fboCache.get();
186 if (!fbo) {
187 LOGW("Could not obtain an FBO");
188 return NULL;
189 }
190
191 glActiveTexture(GL_TEXTURE0);
192 Layer* layer = Caches::getInstance().layerCache.get(width, height);
193 if (!layer) {
194 LOGW("Could not obtain a layer");
195 return NULL;
196 }
197
Romain Guy9ace8f52011-07-07 20:50:11 -0700198 layer->setFbo(fbo);
Romain Guy09b7c912011-02-02 20:28:09 -0800199 layer->layer.set(0.0f, 0.0f, width, height);
Romain Guy9ace8f52011-07-07 20:50:11 -0700200 layer->texCoords.set(0.0f, height / float(layer->getHeight()),
201 width / float(layer->getWidth()), 0.0f);
202 layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
203 layer->setBlend(!isOpaque);
204 layer->setColorFilter(NULL);
Romain Guy09b7c912011-02-02 20:28:09 -0800205 layer->region.clear();
Romain Guyada830f2011-01-13 12:13:20 -0800206
Romain Guy6c319ca2011-01-11 14:29:25 -0800207 GLuint previousFbo;
208 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo);
209
Romain Guy9ace8f52011-07-07 20:50:11 -0700210 glBindFramebuffer(GL_FRAMEBUFFER, layer->getFbo());
211 layer->bindTexture();
Romain Guy6c319ca2011-01-11 14:29:25 -0800212
Romain Guy09b7c912011-02-02 20:28:09 -0800213 // Initialize the texture if needed
Romain Guy9ace8f52011-07-07 20:50:11 -0700214 if (layer->isEmpty()) {
215 layer->setEmpty(false);
216 layer->allocateTexture(GL_RGBA, GL_UNSIGNED_BYTE);
Romain Guy6c319ca2011-01-11 14:29:25 -0800217
Romain Guy09b7c912011-02-02 20:28:09 -0800218 if (glGetError() != GL_NO_ERROR) {
Romain Guy5cd5c3f2011-10-17 17:10:02 -0700219 LOGD("Could not allocate texture for layer (fbo=%d %dx%d)",
220 fbo, width, height);
Romain Guy9ace8f52011-07-07 20:50:11 -0700221
Romain Guy09b7c912011-02-02 20:28:09 -0800222 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
Romain Guy09b7c912011-02-02 20:28:09 -0800223 Caches::getInstance().fboCache.put(fbo);
Romain Guy9ace8f52011-07-07 20:50:11 -0700224
225 layer->deleteTexture();
Romain Guy09b7c912011-02-02 20:28:09 -0800226 delete layer;
Romain Guy9ace8f52011-07-07 20:50:11 -0700227
Romain Guy09b7c912011-02-02 20:28:09 -0800228 return NULL;
229 }
Romain Guy6c319ca2011-01-11 14:29:25 -0800230 }
231
232 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
Romain Guy9ace8f52011-07-07 20:50:11 -0700233 layer->getTexture(), 0);
Romain Guy6c319ca2011-01-11 14:29:25 -0800234
Romain Guy40a787f2011-03-02 15:15:42 -0800235 glDisable(GL_SCISSOR_TEST);
236 glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
237 glClear(GL_COLOR_BUFFER_BIT);
238 glEnable(GL_SCISSOR_TEST);
239
Romain Guy6c319ca2011-01-11 14:29:25 -0800240 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
241
Romain Guyada830f2011-01-13 12:13:20 -0800242 return layer;
Romain Guy6c319ca2011-01-11 14:29:25 -0800243}
244
Romain Guyada830f2011-01-13 12:13:20 -0800245bool LayerRenderer::resizeLayer(Layer* layer, uint32_t width, uint32_t height) {
246 if (layer) {
Romain Guy9ace8f52011-07-07 20:50:11 -0700247 LAYER_RENDERER_LOGD("Resizing layer fbo = %d to %dx%d", layer->getFbo(), width, height);
Romain Guy1fc883b2011-01-12 14:30:59 -0800248
Romain Guy09b7c912011-02-02 20:28:09 -0800249 if (Caches::getInstance().layerCache.resize(layer, width, height)) {
250 layer->layer.set(0.0f, 0.0f, width, height);
Romain Guy9ace8f52011-07-07 20:50:11 -0700251 layer->texCoords.set(0.0f, height / float(layer->getHeight()),
252 width / float(layer->getWidth()), 0.0f);
Romain Guy09b7c912011-02-02 20:28:09 -0800253 } else {
Romain Guy9ace8f52011-07-07 20:50:11 -0700254 layer->deleteTexture();
Romain Guy09b7c912011-02-02 20:28:09 -0800255 delete layer;
Romain Guyada830f2011-01-13 12:13:20 -0800256 return false;
257 }
Romain Guy6c319ca2011-01-11 14:29:25 -0800258 }
Romain Guy09b7c912011-02-02 20:28:09 -0800259
Romain Guyada830f2011-01-13 12:13:20 -0800260 return true;
Romain Guy6c319ca2011-01-11 14:29:25 -0800261}
262
Romain Guy4a5a7152011-06-24 17:53:53 -0700263Layer* LayerRenderer::createTextureLayer(bool isOpaque) {
264 LAYER_RENDERER_LOGD("Creating new texture layer");
265
266 Layer* layer = new Layer(0, 0);
Romain Guy9ace8f52011-07-07 20:50:11 -0700267 layer->setCacheable(false);
268 layer->setTextureLayer(true);
269 layer->setBlend(!isOpaque);
270 layer->setEmpty(true);
271 layer->setFbo(0);
272 layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
Romain Guy4a5a7152011-06-24 17:53:53 -0700273 layer->layer.set(0.0f, 0.0f, 0.0f, 0.0f);
Romain Guya9dc86b2011-10-11 14:06:21 -0700274 layer->texCoords.set(0.0f, 1.0f, 1.0f, 0.0f);
Romain Guy4a5a7152011-06-24 17:53:53 -0700275 layer->region.clear();
Romain Guy9ace8f52011-07-07 20:50:11 -0700276 layer->setRenderTarget(GL_NONE); // see ::updateTextureLayer()
Romain Guy4a5a7152011-06-24 17:53:53 -0700277
278 glActiveTexture(GL_TEXTURE0);
Romain Guy9ace8f52011-07-07 20:50:11 -0700279 layer->generateTexture();
Romain Guy4a5a7152011-06-24 17:53:53 -0700280
281 return layer;
282}
283
Romain Guyaa6c24c2011-04-28 18:40:04 -0700284void LayerRenderer::updateTextureLayer(Layer* layer, uint32_t width, uint32_t height,
Romain Guya9489272011-06-22 20:58:11 -0700285 bool isOpaque, GLenum renderTarget, float* transform) {
Romain Guyaa6c24c2011-04-28 18:40:04 -0700286 if (layer) {
Romain Guy9ace8f52011-07-07 20:50:11 -0700287 layer->setBlend(!isOpaque);
288 layer->setSize(width, height);
Romain Guyaa6c24c2011-04-28 18:40:04 -0700289 layer->layer.set(0.0f, 0.0f, width, height);
290 layer->region.set(width, height);
291 layer->regionRect.set(0.0f, 0.0f, width, height);
Romain Guy9ace8f52011-07-07 20:50:11 -0700292 layer->getTexTransform().load(transform);
Romain Guy8f0095c2011-05-02 17:24:22 -0700293
Romain Guy9ace8f52011-07-07 20:50:11 -0700294 if (renderTarget != layer->getRenderTarget()) {
295 layer->setRenderTarget(renderTarget);
296 layer->bindTexture();
Romain Guyd21b6e12011-11-30 20:21:23 -0800297 layer->setFilter(GL_NEAREST, false, true);
298 layer->setWrap(GL_CLAMP_TO_EDGE, false, true);
Romain Guy4a5a7152011-06-24 17:53:53 -0700299 }
Romain Guyaa6c24c2011-04-28 18:40:04 -0700300 }
301}
302
Romain Guyada830f2011-01-13 12:13:20 -0800303void LayerRenderer::destroyLayer(Layer* layer) {
304 if (layer) {
Romain Guyeea60692011-07-26 20:35:55 -0700305 LAYER_RENDERER_LOGD("Recycling layer, %dx%d fbo = %d",
306 layer->getWidth(), layer->getHeight(), layer->getFbo());
Romain Guy1fc883b2011-01-12 14:30:59 -0800307
Dave Burke70775062011-11-14 11:39:30 -0800308 if (layer->getFbo()) {
309 Caches::getInstance().fboCache.put(layer->getFbo());
Romain Guy09b7c912011-02-02 20:28:09 -0800310 }
Romain Guyada830f2011-01-13 12:13:20 -0800311
Romain Guy09b7c912011-02-02 20:28:09 -0800312 if (!Caches::getInstance().layerCache.put(layer)) {
Romain Guyeea60692011-07-26 20:35:55 -0700313 LAYER_RENDERER_LOGD(" Destroyed!");
Romain Guy9ace8f52011-07-07 20:50:11 -0700314 layer->deleteTexture();
Romain Guy09b7c912011-02-02 20:28:09 -0800315 delete layer;
316 } else {
Romain Guyeea60692011-07-26 20:35:55 -0700317 LAYER_RENDERER_LOGD(" Cached!");
Romain Guy65b345f2011-07-27 18:51:50 -0700318#if DEBUG_LAYER_RENDERER
Romain Guyeea60692011-07-26 20:35:55 -0700319 Caches::getInstance().layerCache.dump();
320#endif
Romain Guy09b7c912011-02-02 20:28:09 -0800321 layer->region.clear();
322 }
Romain Guyada830f2011-01-13 12:13:20 -0800323 }
Romain Guy6c319ca2011-01-11 14:29:25 -0800324}
325
Romain Guyada830f2011-01-13 12:13:20 -0800326void LayerRenderer::destroyLayerDeferred(Layer* layer) {
327 if (layer) {
Romain Guy9ace8f52011-07-07 20:50:11 -0700328 LAYER_RENDERER_LOGD("Deferring layer destruction, fbo = %d", layer->getFbo());
Romain Guy1fc883b2011-01-12 14:30:59 -0800329
Romain Guyada830f2011-01-13 12:13:20 -0800330 Caches::getInstance().deleteLayerDeferred(layer);
331 }
Romain Guy57066eb2011-01-12 12:53:32 -0800332}
333
Romain Guy77a81162011-06-14 16:45:55 -0700334bool LayerRenderer::copyLayer(Layer* layer, SkBitmap* bitmap) {
335 Caches& caches = Caches::getInstance();
Romain Guy9ace8f52011-07-07 20:50:11 -0700336 if (layer && layer->isTextureLayer() && bitmap->width() <= caches.maxTextureSize &&
Romain Guy77a81162011-06-14 16:45:55 -0700337 bitmap->height() <= caches.maxTextureSize) {
338
339 GLuint fbo = caches.fboCache.get();
340 if (!fbo) {
341 LOGW("Could not obtain an FBO");
342 return false;
343 }
344
Romain Guyd6b2a002011-06-17 17:45:59 -0700345 SkAutoLockPixels alp(*bitmap);
346
Romain Guy77a81162011-06-14 16:45:55 -0700347 GLuint texture;
348 GLuint previousFbo;
349
350 GLenum format;
351 GLenum type;
352
Romain Guyd6b2a002011-06-17 17:45:59 -0700353 GLenum error = GL_NO_ERROR;
354 bool status = false;
355
Romain Guy77a81162011-06-14 16:45:55 -0700356 switch (bitmap->config()) {
357 case SkBitmap::kA8_Config:
358 format = GL_ALPHA;
359 type = GL_UNSIGNED_BYTE;
360 break;
361 case SkBitmap::kRGB_565_Config:
362 format = GL_RGB;
363 type = GL_UNSIGNED_SHORT_5_6_5;
364 break;
365 case SkBitmap::kARGB_4444_Config:
366 format = GL_RGBA;
367 type = GL_UNSIGNED_SHORT_4_4_4_4;
368 break;
369 case SkBitmap::kARGB_8888_Config:
370 default:
371 format = GL_RGBA;
372 type = GL_UNSIGNED_BYTE;
373 break;
374 }
375
Romain Guy9ace8f52011-07-07 20:50:11 -0700376 float alpha = layer->getAlpha();
377 SkXfermode::Mode mode = layer->getMode();
Romain Guyd6b2a002011-06-17 17:45:59 -0700378
Romain Guy9ace8f52011-07-07 20:50:11 -0700379 layer->setAlpha(255, SkXfermode::kSrc_Mode);
380 layer->setFbo(fbo);
Romain Guyd6b2a002011-06-17 17:45:59 -0700381
Romain Guy77a81162011-06-14 16:45:55 -0700382 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo);
383 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
384
385 glGenTextures(1, &texture);
Romain Guyd6b2a002011-06-17 17:45:59 -0700386 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700387
388 glActiveTexture(GL_TEXTURE0);
389 glBindTexture(GL_TEXTURE_2D, texture);
390
Romain Guyec19b4a2011-07-07 21:05:04 -0700391 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
392 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
Romain Guy77a81162011-06-14 16:45:55 -0700393
394 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
395 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
396
397 glTexImage2D(GL_TEXTURE_2D, 0, format, bitmap->width(), bitmap->height(),
398 0, format, type, NULL);
Romain Guyd6b2a002011-06-17 17:45:59 -0700399 if ((error = glGetError()) != GL_NO_ERROR) goto error;
400
Romain Guy77a81162011-06-14 16:45:55 -0700401 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
402 GL_TEXTURE_2D, texture, 0);
Romain Guyd6b2a002011-06-17 17:45:59 -0700403 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700404
Romain Guyd6b2a002011-06-17 17:45:59 -0700405 {
406 LayerRenderer renderer(layer);
407 renderer.setViewport(bitmap->width(), bitmap->height());
408 renderer.OpenGLRenderer::prepareDirty(0.0f, 0.0f,
Romain Guy9ace8f52011-07-07 20:50:11 -0700409 bitmap->width(), bitmap->height(), !layer->isBlend());
Romain Guya9dc86b2011-10-11 14:06:21 -0700410
411 glDisable(GL_SCISSOR_TEST);
412 renderer.translate(0.0f, bitmap->height());
413 renderer.scale(1.0f, -1.0f);
414
415 mat4 texTransform(layer->getTexTransform());
416
417 mat4 invert;
418 invert.translate(0.0f, 1.0f, 0.0f);
419 invert.scale(1.0f, -1.0f, 1.0f);
420 layer->getTexTransform().multiply(invert);
421
Romain Guyd6b2a002011-06-17 17:45:59 -0700422 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700423
Romain Guyd6b2a002011-06-17 17:45:59 -0700424 {
425 Rect bounds;
426 bounds.set(0.0f, 0.0f, bitmap->width(), bitmap->height());
427 renderer.drawTextureLayer(layer, bounds);
Romain Guy77a81162011-06-14 16:45:55 -0700428
Romain Guyd6b2a002011-06-17 17:45:59 -0700429 glReadPixels(0, 0, bitmap->width(), bitmap->height(), format,
430 type, bitmap->getPixels());
Romain Guy77a81162011-06-14 16:45:55 -0700431
Romain Guyd6b2a002011-06-17 17:45:59 -0700432 if ((error = glGetError()) != GL_NO_ERROR) goto error;
433 }
Romain Guy77a81162011-06-14 16:45:55 -0700434
Romain Guya9dc86b2011-10-11 14:06:21 -0700435 layer->getTexTransform().load(texTransform);
Romain Guyd6b2a002011-06-17 17:45:59 -0700436 status = true;
437 }
Romain Guy77a81162011-06-14 16:45:55 -0700438
Romain Guyd6b2a002011-06-17 17:45:59 -0700439error:
440#if DEBUG_OPENGL
441 if (error != GL_NO_ERROR) {
442 LOGD("GL error while copying layer into bitmap = 0x%x", error);
443 }
444#endif
Romain Guy77a81162011-06-14 16:45:55 -0700445
446 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
Romain Guy9ace8f52011-07-07 20:50:11 -0700447 layer->setAlpha(alpha, mode);
448 layer->setFbo(0);
Romain Guy77a81162011-06-14 16:45:55 -0700449 glDeleteTextures(1, &texture);
450 caches.fboCache.put(fbo);
451
Romain Guyd6b2a002011-06-17 17:45:59 -0700452 return status;
Romain Guy77a81162011-06-14 16:45:55 -0700453 }
454 return false;
455}
456
Romain Guy6c319ca2011-01-11 14:29:25 -0800457}; // namespace uirenderer
458}; // namespace android