blob: e320eb2e0047fd32e67ac9a9e234c15c1587f08b [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 Guya1d3c912011-12-13 14:55:06 -0800185 Caches& caches = Caches::getInstance();
186 GLuint fbo = caches.fboCache.get();
Romain Guy09b7c912011-02-02 20:28:09 -0800187 if (!fbo) {
Steve Block8564c8d2012-01-05 23:22:43 +0000188 ALOGW("Could not obtain an FBO");
Romain Guy09b7c912011-02-02 20:28:09 -0800189 return NULL;
190 }
191
Romain Guya1d3c912011-12-13 14:55:06 -0800192 caches.activeTexture(0);
193 Layer* layer = caches.layerCache.get(width, height);
Romain Guy09b7c912011-02-02 20:28:09 -0800194 if (!layer) {
Steve Block8564c8d2012-01-05 23:22:43 +0000195 ALOGW("Could not obtain a layer");
Romain Guy09b7c912011-02-02 20:28:09 -0800196 return NULL;
197 }
198
Romain Guy9ace8f52011-07-07 20:50:11 -0700199 layer->setFbo(fbo);
Romain Guy09b7c912011-02-02 20:28:09 -0800200 layer->layer.set(0.0f, 0.0f, width, height);
Romain Guy9ace8f52011-07-07 20:50:11 -0700201 layer->texCoords.set(0.0f, height / float(layer->getHeight()),
202 width / float(layer->getWidth()), 0.0f);
203 layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
204 layer->setBlend(!isOpaque);
205 layer->setColorFilter(NULL);
Romain Guy09b7c912011-02-02 20:28:09 -0800206 layer->region.clear();
Romain Guyada830f2011-01-13 12:13:20 -0800207
Romain Guy6c319ca2011-01-11 14:29:25 -0800208 GLuint previousFbo;
209 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo);
210
Romain Guy9ace8f52011-07-07 20:50:11 -0700211 glBindFramebuffer(GL_FRAMEBUFFER, layer->getFbo());
212 layer->bindTexture();
Romain Guy6c319ca2011-01-11 14:29:25 -0800213
Romain Guy09b7c912011-02-02 20:28:09 -0800214 // Initialize the texture if needed
Romain Guy9ace8f52011-07-07 20:50:11 -0700215 if (layer->isEmpty()) {
216 layer->setEmpty(false);
217 layer->allocateTexture(GL_RGBA, GL_UNSIGNED_BYTE);
Romain Guy6c319ca2011-01-11 14:29:25 -0800218
Romain Guy09b7c912011-02-02 20:28:09 -0800219 if (glGetError() != GL_NO_ERROR) {
Steve Block5baa3a62011-12-20 16:23:08 +0000220 ALOGD("Could not allocate texture for layer (fbo=%d %dx%d)",
Romain Guy5cd5c3f2011-10-17 17:10:02 -0700221 fbo, width, height);
Romain Guy9ace8f52011-07-07 20:50:11 -0700222
Romain Guy09b7c912011-02-02 20:28:09 -0800223 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
Romain Guya1d3c912011-12-13 14:55:06 -0800224 caches.fboCache.put(fbo);
Romain Guy9ace8f52011-07-07 20:50:11 -0700225
226 layer->deleteTexture();
Romain Guy09b7c912011-02-02 20:28:09 -0800227 delete layer;
Romain Guy9ace8f52011-07-07 20:50:11 -0700228
Romain Guy09b7c912011-02-02 20:28:09 -0800229 return NULL;
230 }
Romain Guy6c319ca2011-01-11 14:29:25 -0800231 }
232
233 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
Romain Guy9ace8f52011-07-07 20:50:11 -0700234 layer->getTexture(), 0);
Romain Guy6c319ca2011-01-11 14:29:25 -0800235
Romain Guy40a787f2011-03-02 15:15:42 -0800236 glDisable(GL_SCISSOR_TEST);
Romain Guy40a787f2011-03-02 15:15:42 -0800237 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
Romain Guya1d3c912011-12-13 14:55:06 -0800278 Caches::getInstance().activeTexture(0);
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
Romain Guy9c4b79a2011-11-10 19:23:58 -0800308 GLuint fbo = layer->getFbo();
309 if (fbo) {
310 flushLayer(layer);
311 Caches::getInstance().fboCache.put(fbo);
Romain Guy09b7c912011-02-02 20:28:09 -0800312 }
Romain Guyada830f2011-01-13 12:13:20 -0800313
Romain Guy09b7c912011-02-02 20:28:09 -0800314 if (!Caches::getInstance().layerCache.put(layer)) {
Romain Guyeea60692011-07-26 20:35:55 -0700315 LAYER_RENDERER_LOGD(" Destroyed!");
Romain Guy9ace8f52011-07-07 20:50:11 -0700316 layer->deleteTexture();
Romain Guy09b7c912011-02-02 20:28:09 -0800317 delete layer;
318 } else {
Romain Guyeea60692011-07-26 20:35:55 -0700319 LAYER_RENDERER_LOGD(" Cached!");
Romain Guy65b345f2011-07-27 18:51:50 -0700320#if DEBUG_LAYER_RENDERER
Romain Guyeea60692011-07-26 20:35:55 -0700321 Caches::getInstance().layerCache.dump();
322#endif
Romain Guy09b7c912011-02-02 20:28:09 -0800323 layer->region.clear();
324 }
Romain Guyada830f2011-01-13 12:13:20 -0800325 }
Romain Guy6c319ca2011-01-11 14:29:25 -0800326}
327
Romain Guyada830f2011-01-13 12:13:20 -0800328void LayerRenderer::destroyLayerDeferred(Layer* layer) {
329 if (layer) {
Romain Guy9ace8f52011-07-07 20:50:11 -0700330 LAYER_RENDERER_LOGD("Deferring layer destruction, fbo = %d", layer->getFbo());
Romain Guy1fc883b2011-01-12 14:30:59 -0800331
Romain Guyada830f2011-01-13 12:13:20 -0800332 Caches::getInstance().deleteLayerDeferred(layer);
333 }
Romain Guy57066eb2011-01-12 12:53:32 -0800334}
335
Romain Guy9c4b79a2011-11-10 19:23:58 -0800336void LayerRenderer::flushLayer(Layer* layer) {
337#ifdef GL_EXT_discard_framebuffer
338 GLuint fbo = layer->getFbo();
339 if (layer && fbo) {
340 // If possible, discard any enqueud operations on deferred
341 // rendering architectures
342 if (Caches::getInstance().extensions.hasDiscardFramebuffer()) {
343 GLuint previousFbo;
344 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo);
345
346 GLenum attachments = GL_COLOR_ATTACHMENT0;
347 if (fbo != previousFbo) glBindFramebuffer(GL_FRAMEBUFFER, fbo);
348 glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, &attachments);
349
350 if (fbo != previousFbo) glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
351 }
352 }
353#endif
354}
355
Romain Guy77a81162011-06-14 16:45:55 -0700356bool LayerRenderer::copyLayer(Layer* layer, SkBitmap* bitmap) {
357 Caches& caches = Caches::getInstance();
Romain Guy9ace8f52011-07-07 20:50:11 -0700358 if (layer && layer->isTextureLayer() && bitmap->width() <= caches.maxTextureSize &&
Romain Guy77a81162011-06-14 16:45:55 -0700359 bitmap->height() <= caches.maxTextureSize) {
360
361 GLuint fbo = caches.fboCache.get();
362 if (!fbo) {
Steve Block8564c8d2012-01-05 23:22:43 +0000363 ALOGW("Could not obtain an FBO");
Romain Guy77a81162011-06-14 16:45:55 -0700364 return false;
365 }
366
Romain Guyd6b2a002011-06-17 17:45:59 -0700367 SkAutoLockPixels alp(*bitmap);
368
Romain Guy77a81162011-06-14 16:45:55 -0700369 GLuint texture;
370 GLuint previousFbo;
371
372 GLenum format;
373 GLenum type;
374
Romain Guyd6b2a002011-06-17 17:45:59 -0700375 GLenum error = GL_NO_ERROR;
376 bool status = false;
377
Romain Guy77a81162011-06-14 16:45:55 -0700378 switch (bitmap->config()) {
379 case SkBitmap::kA8_Config:
380 format = GL_ALPHA;
381 type = GL_UNSIGNED_BYTE;
382 break;
383 case SkBitmap::kRGB_565_Config:
384 format = GL_RGB;
385 type = GL_UNSIGNED_SHORT_5_6_5;
386 break;
387 case SkBitmap::kARGB_4444_Config:
388 format = GL_RGBA;
389 type = GL_UNSIGNED_SHORT_4_4_4_4;
390 break;
391 case SkBitmap::kARGB_8888_Config:
392 default:
393 format = GL_RGBA;
394 type = GL_UNSIGNED_BYTE;
395 break;
396 }
397
Romain Guy9ace8f52011-07-07 20:50:11 -0700398 float alpha = layer->getAlpha();
399 SkXfermode::Mode mode = layer->getMode();
Romain Guyd6b2a002011-06-17 17:45:59 -0700400
Romain Guy9ace8f52011-07-07 20:50:11 -0700401 layer->setAlpha(255, SkXfermode::kSrc_Mode);
402 layer->setFbo(fbo);
Romain Guyd6b2a002011-06-17 17:45:59 -0700403
Romain Guy77a81162011-06-14 16:45:55 -0700404 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo);
405 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
406
407 glGenTextures(1, &texture);
Romain Guyd6b2a002011-06-17 17:45:59 -0700408 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700409
Romain Guya1d3c912011-12-13 14:55:06 -0800410 caches.activeTexture(0);
Romain Guy77a81162011-06-14 16:45:55 -0700411 glBindTexture(GL_TEXTURE_2D, texture);
412
Romain Guyec19b4a2011-07-07 21:05:04 -0700413 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
414 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
Romain Guy77a81162011-06-14 16:45:55 -0700415
416 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
417 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
418
419 glTexImage2D(GL_TEXTURE_2D, 0, format, bitmap->width(), bitmap->height(),
420 0, format, type, NULL);
Romain Guyd6b2a002011-06-17 17:45:59 -0700421 if ((error = glGetError()) != GL_NO_ERROR) goto error;
422
Romain Guy77a81162011-06-14 16:45:55 -0700423 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
424 GL_TEXTURE_2D, texture, 0);
Romain Guyd6b2a002011-06-17 17:45:59 -0700425 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700426
Romain Guyd6b2a002011-06-17 17:45:59 -0700427 {
428 LayerRenderer renderer(layer);
429 renderer.setViewport(bitmap->width(), bitmap->height());
430 renderer.OpenGLRenderer::prepareDirty(0.0f, 0.0f,
Romain Guy9ace8f52011-07-07 20:50:11 -0700431 bitmap->width(), bitmap->height(), !layer->isBlend());
Romain Guya9dc86b2011-10-11 14:06:21 -0700432
433 glDisable(GL_SCISSOR_TEST);
434 renderer.translate(0.0f, bitmap->height());
435 renderer.scale(1.0f, -1.0f);
436
437 mat4 texTransform(layer->getTexTransform());
438
439 mat4 invert;
440 invert.translate(0.0f, 1.0f, 0.0f);
441 invert.scale(1.0f, -1.0f, 1.0f);
442 layer->getTexTransform().multiply(invert);
443
Romain Guyd6b2a002011-06-17 17:45:59 -0700444 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700445
Romain Guyd6b2a002011-06-17 17:45:59 -0700446 {
447 Rect bounds;
448 bounds.set(0.0f, 0.0f, bitmap->width(), bitmap->height());
449 renderer.drawTextureLayer(layer, bounds);
Romain Guy77a81162011-06-14 16:45:55 -0700450
Romain Guyd6b2a002011-06-17 17:45:59 -0700451 glReadPixels(0, 0, bitmap->width(), bitmap->height(), format,
452 type, bitmap->getPixels());
Romain Guy77a81162011-06-14 16:45:55 -0700453
Romain Guyd6b2a002011-06-17 17:45:59 -0700454 if ((error = glGetError()) != GL_NO_ERROR) goto error;
455 }
Romain Guy77a81162011-06-14 16:45:55 -0700456
Romain Guya9dc86b2011-10-11 14:06:21 -0700457 layer->getTexTransform().load(texTransform);
Romain Guyd6b2a002011-06-17 17:45:59 -0700458 status = true;
459 }
Romain Guy77a81162011-06-14 16:45:55 -0700460
Romain Guyd6b2a002011-06-17 17:45:59 -0700461error:
Romain Guy39d252a2011-12-12 18:14:06 -0800462 glEnable(GL_SCISSOR_TEST);
463
Romain Guyd6b2a002011-06-17 17:45:59 -0700464#if DEBUG_OPENGL
465 if (error != GL_NO_ERROR) {
Steve Block5baa3a62011-12-20 16:23:08 +0000466 ALOGD("GL error while copying layer into bitmap = 0x%x", error);
Romain Guyd6b2a002011-06-17 17:45:59 -0700467 }
468#endif
Romain Guy77a81162011-06-14 16:45:55 -0700469
470 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
Romain Guy9ace8f52011-07-07 20:50:11 -0700471 layer->setAlpha(alpha, mode);
472 layer->setFbo(0);
Romain Guy77a81162011-06-14 16:45:55 -0700473 glDeleteTextures(1, &texture);
474 caches.fboCache.put(fbo);
475
Romain Guyd6b2a002011-06-17 17:45:59 -0700476 return status;
Romain Guy77a81162011-06-14 16:45:55 -0700477 }
478 return false;
479}
480
Romain Guy6c319ca2011-01-11 14:29:25 -0800481}; // namespace uirenderer
482}; // namespace android