blob: f8076cc414d05519f54b5cde679bc6d068f3f632 [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 Guy7c25aab2012-10-18 15:05:02 -070021#include <private/hwui/DrawGlInfo.h>
22
Romain Guy09b7c912011-02-02 20:28:09 -080023#include "LayerCache.h"
Romain Guy6c319ca2011-01-11 14:29:25 -080024#include "LayerRenderer.h"
Romain Guyaa6c24c2011-04-28 18:40:04 -070025#include "Matrix.h"
Romain Guy1fc883b2011-01-12 14:30:59 -080026#include "Properties.h"
Romain Guy3a3133d2011-02-01 22:59:58 -080027#include "Rect.h"
Romain Guy6c319ca2011-01-11 14:29:25 -080028
29namespace android {
30namespace uirenderer {
31
32///////////////////////////////////////////////////////////////////////////////
33// Rendering
34///////////////////////////////////////////////////////////////////////////////
35
Romain Guy79537452011-10-12 13:48:51 -070036LayerRenderer::LayerRenderer(Layer* layer): mLayer(layer) {
37}
38
39LayerRenderer::~LayerRenderer() {
40}
41
Romain Guy35643dd2012-09-18 15:40:58 -070042void LayerRenderer::setViewport(int width, int height) {
43 initViewport(width, height);
44}
45
Romain Guy7c25aab2012-10-18 15:05:02 -070046status_t LayerRenderer::prepareDirty(float left, float top, float right, float bottom,
47 bool opaque) {
Romain Guy9ace8f52011-07-07 20:50:11 -070048 LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->getFbo());
Romain Guy1fc883b2011-01-12 14:30:59 -080049
Romain Guy9ace8f52011-07-07 20:50:11 -070050 glBindFramebuffer(GL_FRAMEBUFFER, mLayer->getFbo());
Romain Guy62687ec2011-02-02 15:44:19 -080051
Romain Guy09b7c912011-02-02 20:28:09 -080052 const float width = mLayer->layer.getWidth();
53 const float height = mLayer->layer.getHeight();
54
Romain Guy3a3133d2011-02-01 22:59:58 -080055 Rect dirty(left, top, right, bottom);
56 if (dirty.isEmpty() || (dirty.left <= 0 && dirty.top <= 0 &&
Romain Guy09b7c912011-02-02 20:28:09 -080057 dirty.right >= width && dirty.bottom >= height)) {
Romain Guy3a3133d2011-02-01 22:59:58 -080058 mLayer->region.clear();
Romain Guy09b7c912011-02-02 20:28:09 -080059 dirty.set(0.0f, 0.0f, width, height);
Romain Guy3a3133d2011-02-01 22:59:58 -080060 } else {
Romain Guy09b7c912011-02-02 20:28:09 -080061 dirty.intersect(0.0f, 0.0f, width, height);
Romain Guy3a3133d2011-02-01 22:59:58 -080062 android::Rect r(dirty.left, dirty.top, dirty.right, dirty.bottom);
63 mLayer->region.subtractSelf(r);
64 }
Romain Guyc3fedaf2013-01-29 17:26:25 -080065 mLayer->clipRect.set(dirty);
Romain Guyc88e3572011-01-22 00:32:12 -080066
Chet Haase44b2fe32012-06-06 19:03:58 -070067 return OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);
Romain Guy6c319ca2011-01-11 14:29:25 -080068}
69
Romain Guy7c25aab2012-10-18 15:05:02 -070070status_t LayerRenderer::clear(float left, float top, float right, float bottom, bool opaque) {
71 if (mLayer->isDirty()) {
72 getCaches().disableScissor();
73 glClear(GL_COLOR_BUFFER_BIT);
74
75 getCaches().resetScissor();
76 mLayer->setDirty(false);
77
78 return DrawGlInfo::kStatusDone;
79 }
80
81 return OpenGLRenderer::clear(left, top, right, bottom, opaque);
82}
83
Romain Guy6c319ca2011-01-11 14:29:25 -080084void LayerRenderer::finish() {
85 OpenGLRenderer::finish();
Romain Guy1fc883b2011-01-12 14:30:59 -080086
Romain Guyf219da52011-01-16 12:54:25 -080087 generateMesh();
88
Romain Guy9ace8f52011-07-07 20:50:11 -070089 LAYER_RENDERER_LOGD("Finished rendering into layer, fbo = %d", mLayer->getFbo());
Romain Guy42f3a4b2011-01-19 13:42:26 -080090
91 // No need to unbind our FBO, this will be taken care of by the caller
92 // who will invoke OpenGLRenderer::resume()
93}
94
Romain Guy624234f2013-03-05 16:43:31 -080095GLint LayerRenderer::getTargetFbo() const {
Romain Guy9ace8f52011-07-07 20:50:11 -070096 return mLayer->getFbo();
Romain Guy6c319ca2011-01-11 14:29:25 -080097}
98
Romain Guy624234f2013-03-05 16:43:31 -080099bool LayerRenderer::suppressErrorChecks() const {
Romain Guy11cb6422012-09-21 00:39:43 -0700100 return true;
101}
102
Romain Guy6c319ca2011-01-11 14:29:25 -0800103///////////////////////////////////////////////////////////////////////////////
Romain Guy8ce00302013-01-15 18:51:42 -0800104// Layer support
Romain Guyf219da52011-01-16 12:54:25 -0800105///////////////////////////////////////////////////////////////////////////////
106
Romain Guy624234f2013-03-05 16:43:31 -0800107bool LayerRenderer::hasLayer() const {
Romain Guyf219da52011-01-16 12:54:25 -0800108 return true;
109}
110
Romain Guy8ce00302013-01-15 18:51:42 -0800111void LayerRenderer::ensureStencilBuffer() {
112 attachStencilBufferToLayer(mLayer);
113}
114
115///////////////////////////////////////////////////////////////////////////////
116// Dirty region tracking
117///////////////////////////////////////////////////////////////////////////////
118
Romain Guy624234f2013-03-05 16:43:31 -0800119Region* LayerRenderer::getRegion() const {
Romain Guyf219da52011-01-16 12:54:25 -0800120 if (getSnapshot()->flags & Snapshot::kFlagFboTarget) {
121 return OpenGLRenderer::getRegion();
122 }
123 return &mLayer->region;
Romain Guyf219da52011-01-16 12:54:25 -0800124}
125
Chris Craik6c5b9be2013-02-27 14:03:19 -0800126// TODO: This implementation uses a very simple approach to fixing T-junctions which keeps the
127// results as rectangles, and is thus not necessarily efficient in the geometry
128// produced. Eventually, it may be better to develop triangle-based mechanism.
Romain Guyf219da52011-01-16 12:54:25 -0800129void LayerRenderer::generateMesh() {
Romain Guyf219da52011-01-16 12:54:25 -0800130 if (mLayer->region.isRect() || mLayer->region.isEmpty()) {
131 if (mLayer->mesh) {
Romain Guy96885eb2013-03-26 15:05:58 -0700132 delete[] mLayer->mesh;
Romain Guyf219da52011-01-16 12:54:25 -0800133 mLayer->mesh = NULL;
Romain Guyf219da52011-01-16 12:54:25 -0800134 mLayer->meshElementCount = 0;
135 }
Romain Guy40667672011-03-18 14:34:03 -0700136
Romain Guy9fc27812011-04-27 14:21:41 -0700137 mLayer->setRegionAsRect();
Romain Guyf219da52011-01-16 12:54:25 -0800138 return;
139 }
140
Chris Craik6c5b9be2013-02-27 14:03:19 -0800141 // avoid T-junctions as they cause artifacts in between the resultant
142 // geometry when complex transforms occur.
143 // TODO: generate the safeRegion only if necessary based on drawing transform (see
144 // OpenGLRenderer::composeLayerRegion())
145 Region safeRegion = Region::createTJunctionFreeRegion(mLayer->region);
146
Romain Guyf219da52011-01-16 12:54:25 -0800147 size_t count;
Chris Craik6c5b9be2013-02-27 14:03:19 -0800148 const android::Rect* rects = safeRegion.getArray(&count);
Romain Guyf219da52011-01-16 12:54:25 -0800149
150 GLsizei elementCount = count * 6;
151
152 if (mLayer->mesh && mLayer->meshElementCount < elementCount) {
Romain Guy96885eb2013-03-26 15:05:58 -0700153 delete[] mLayer->mesh;
Romain Guyf219da52011-01-16 12:54:25 -0800154 mLayer->mesh = NULL;
Romain Guyf219da52011-01-16 12:54:25 -0800155 }
156
157 if (!mLayer->mesh) {
158 mLayer->mesh = new TextureVertex[count * 4];
Romain Guyf219da52011-01-16 12:54:25 -0800159 }
Romain Guy4f09f542011-01-26 22:41:43 -0800160 mLayer->meshElementCount = elementCount;
Romain Guyf219da52011-01-16 12:54:25 -0800161
Romain Guy9ace8f52011-07-07 20:50:11 -0700162 const float texX = 1.0f / float(mLayer->getWidth());
163 const float texY = 1.0f / float(mLayer->getHeight());
Romain Guyf219da52011-01-16 12:54:25 -0800164 const float height = mLayer->layer.getHeight();
165
166 TextureVertex* mesh = mLayer->mesh;
Romain Guyf219da52011-01-16 12:54:25 -0800167
168 for (size_t i = 0; i < count; i++) {
169 const android::Rect* r = &rects[i];
170
171 const float u1 = r->left * texX;
172 const float v1 = (height - r->top) * texY;
173 const float u2 = r->right * texX;
174 const float v2 = (height - r->bottom) * texY;
175
176 TextureVertex::set(mesh++, r->left, r->top, u1, v1);
177 TextureVertex::set(mesh++, r->right, r->top, u2, v1);
178 TextureVertex::set(mesh++, r->left, r->bottom, u1, v2);
179 TextureVertex::set(mesh++, r->right, r->bottom, u2, v2);
Romain Guyf219da52011-01-16 12:54:25 -0800180 }
Romain Guyf219da52011-01-16 12:54:25 -0800181}
182
183///////////////////////////////////////////////////////////////////////////////
184// Layers management
Romain Guy6c319ca2011-01-11 14:29:25 -0800185///////////////////////////////////////////////////////////////////////////////
186
Romain Guyada830f2011-01-13 12:13:20 -0800187Layer* LayerRenderer::createLayer(uint32_t width, uint32_t height, bool isOpaque) {
Romain Guyeea60692011-07-26 20:35:55 -0700188 LAYER_RENDERER_LOGD("Requesting new render layer %dx%d", width, height);
Romain Guy1fc883b2011-01-12 14:30:59 -0800189
Romain Guya1d3c912011-12-13 14:55:06 -0800190 Caches& caches = Caches::getInstance();
191 GLuint fbo = caches.fboCache.get();
Romain Guy09b7c912011-02-02 20:28:09 -0800192 if (!fbo) {
Steve Block8564c8d2012-01-05 23:22:43 +0000193 ALOGW("Could not obtain an FBO");
Romain Guy09b7c912011-02-02 20:28:09 -0800194 return NULL;
195 }
196
Romain Guya1d3c912011-12-13 14:55:06 -0800197 caches.activeTexture(0);
198 Layer* layer = caches.layerCache.get(width, height);
Romain Guy09b7c912011-02-02 20:28:09 -0800199 if (!layer) {
Steve Block8564c8d2012-01-05 23:22:43 +0000200 ALOGW("Could not obtain a layer");
Romain Guy09b7c912011-02-02 20:28:09 -0800201 return NULL;
202 }
203
Romain Guyce4a7df2013-03-28 11:32:33 -0700204 // We first obtain a layer before comparing against the max texture size
205 // because layers are not allocated at the exact desired size. They are
206 // always created slighly larger to improve recycling
207 const uint32_t maxTextureSize = caches.maxTextureSize;
208 if (layer->getWidth() > maxTextureSize || layer->getHeight() > maxTextureSize) {
209 ALOGW("Layer exceeds max. dimensions supported by the GPU (%dx%d, max=%dx%d)",
210 width, height, maxTextureSize, maxTextureSize);
211
212 // Creating a new layer always increment its refcount by 1, this allows
213 // us to destroy the layer object if one was created for us
214 Caches::getInstance().resourceCache.decrementRefcount(layer);
215
216 return NULL;
217 }
218
Romain Guy9ace8f52011-07-07 20:50:11 -0700219 layer->setFbo(fbo);
Romain Guy09b7c912011-02-02 20:28:09 -0800220 layer->layer.set(0.0f, 0.0f, width, height);
Romain Guy9ace8f52011-07-07 20:50:11 -0700221 layer->texCoords.set(0.0f, height / float(layer->getHeight()),
222 width / float(layer->getWidth()), 0.0f);
223 layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
224 layer->setBlend(!isOpaque);
225 layer->setColorFilter(NULL);
Romain Guy7c25aab2012-10-18 15:05:02 -0700226 layer->setDirty(true);
Romain Guy09b7c912011-02-02 20:28:09 -0800227 layer->region.clear();
Romain Guyada830f2011-01-13 12:13:20 -0800228
Romain Guy6c319ca2011-01-11 14:29:25 -0800229 GLuint previousFbo;
230 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo);
231
Romain Guy9ace8f52011-07-07 20:50:11 -0700232 glBindFramebuffer(GL_FRAMEBUFFER, layer->getFbo());
233 layer->bindTexture();
Romain Guy6c319ca2011-01-11 14:29:25 -0800234
Romain Guy09b7c912011-02-02 20:28:09 -0800235 // Initialize the texture if needed
Romain Guy9ace8f52011-07-07 20:50:11 -0700236 if (layer->isEmpty()) {
237 layer->setEmpty(false);
Romain Guy09087642013-04-04 12:27:54 -0700238 layer->allocateTexture();
Romain Guy6c319ca2011-01-11 14:29:25 -0800239
Romain Guyce4a7df2013-03-28 11:32:33 -0700240 // This should only happen if we run out of memory
Romain Guy09b7c912011-02-02 20:28:09 -0800241 if (glGetError() != GL_NO_ERROR) {
Romain Guyce4a7df2013-03-28 11:32:33 -0700242 ALOGE("Could not allocate texture for layer (fbo=%d %dx%d)", fbo, width, height);
Romain Guy09b7c912011-02-02 20:28:09 -0800243 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
Romain Guyce4a7df2013-03-28 11:32:33 -0700244 caches.resourceCache.decrementRefcount(layer);
Romain Guy09b7c912011-02-02 20:28:09 -0800245 return NULL;
246 }
Romain Guy6c319ca2011-01-11 14:29:25 -0800247 }
248
249 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
Romain Guy9ace8f52011-07-07 20:50:11 -0700250 layer->getTexture(), 0);
Romain Guy6c319ca2011-01-11 14:29:25 -0800251
Romain Guy6c319ca2011-01-11 14:29:25 -0800252 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
253
Romain Guyada830f2011-01-13 12:13:20 -0800254 return layer;
Romain Guy6c319ca2011-01-11 14:29:25 -0800255}
256
Romain Guyada830f2011-01-13 12:13:20 -0800257bool LayerRenderer::resizeLayer(Layer* layer, uint32_t width, uint32_t height) {
258 if (layer) {
Romain Guy9ace8f52011-07-07 20:50:11 -0700259 LAYER_RENDERER_LOGD("Resizing layer fbo = %d to %dx%d", layer->getFbo(), width, height);
Romain Guy1fc883b2011-01-12 14:30:59 -0800260
Romain Guy2055aba2013-01-18 16:42:51 -0800261 if (layer->resize(width, height)) {
Romain Guy09b7c912011-02-02 20:28:09 -0800262 layer->layer.set(0.0f, 0.0f, width, height);
Romain Guy9ace8f52011-07-07 20:50:11 -0700263 layer->texCoords.set(0.0f, height / float(layer->getHeight()),
264 width / float(layer->getWidth()), 0.0f);
Romain Guy09b7c912011-02-02 20:28:09 -0800265 } else {
Romain Guyada830f2011-01-13 12:13:20 -0800266 return false;
267 }
Romain Guy6c319ca2011-01-11 14:29:25 -0800268 }
Romain Guy09b7c912011-02-02 20:28:09 -0800269
Romain Guyada830f2011-01-13 12:13:20 -0800270 return true;
Romain Guy6c319ca2011-01-11 14:29:25 -0800271}
272
Romain Guy4a5a7152011-06-24 17:53:53 -0700273Layer* LayerRenderer::createTextureLayer(bool isOpaque) {
274 LAYER_RENDERER_LOGD("Creating new texture layer");
275
276 Layer* layer = new Layer(0, 0);
Romain Guy9ace8f52011-07-07 20:50:11 -0700277 layer->setCacheable(false);
278 layer->setTextureLayer(true);
279 layer->setBlend(!isOpaque);
280 layer->setEmpty(true);
281 layer->setFbo(0);
282 layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
Romain Guy4a5a7152011-06-24 17:53:53 -0700283 layer->layer.set(0.0f, 0.0f, 0.0f, 0.0f);
Romain Guya9dc86b2011-10-11 14:06:21 -0700284 layer->texCoords.set(0.0f, 1.0f, 1.0f, 0.0f);
Romain Guy4a5a7152011-06-24 17:53:53 -0700285 layer->region.clear();
Romain Guy9ace8f52011-07-07 20:50:11 -0700286 layer->setRenderTarget(GL_NONE); // see ::updateTextureLayer()
Romain Guy4a5a7152011-06-24 17:53:53 -0700287
Romain Guya1d3c912011-12-13 14:55:06 -0800288 Caches::getInstance().activeTexture(0);
Romain Guy9ace8f52011-07-07 20:50:11 -0700289 layer->generateTexture();
Romain Guy4a5a7152011-06-24 17:53:53 -0700290
291 return layer;
292}
293
Romain Guyaa6c24c2011-04-28 18:40:04 -0700294void LayerRenderer::updateTextureLayer(Layer* layer, uint32_t width, uint32_t height,
Romain Guya9489272011-06-22 20:58:11 -0700295 bool isOpaque, GLenum renderTarget, float* transform) {
Romain Guyaa6c24c2011-04-28 18:40:04 -0700296 if (layer) {
Romain Guy9ace8f52011-07-07 20:50:11 -0700297 layer->setBlend(!isOpaque);
298 layer->setSize(width, height);
Romain Guyaa6c24c2011-04-28 18:40:04 -0700299 layer->layer.set(0.0f, 0.0f, width, height);
300 layer->region.set(width, height);
301 layer->regionRect.set(0.0f, 0.0f, width, height);
Romain Guy9ace8f52011-07-07 20:50:11 -0700302 layer->getTexTransform().load(transform);
Romain Guy8f0095c2011-05-02 17:24:22 -0700303
Romain Guy9ace8f52011-07-07 20:50:11 -0700304 if (renderTarget != layer->getRenderTarget()) {
305 layer->setRenderTarget(renderTarget);
306 layer->bindTexture();
Romain Guyd21b6e12011-11-30 20:21:23 -0800307 layer->setFilter(GL_NEAREST, false, true);
308 layer->setWrap(GL_CLAMP_TO_EDGE, false, true);
Romain Guy4a5a7152011-06-24 17:53:53 -0700309 }
Romain Guyaa6c24c2011-04-28 18:40:04 -0700310 }
311}
312
Romain Guyada830f2011-01-13 12:13:20 -0800313void LayerRenderer::destroyLayer(Layer* layer) {
314 if (layer) {
Romain Guyeea60692011-07-26 20:35:55 -0700315 LAYER_RENDERER_LOGD("Recycling layer, %dx%d fbo = %d",
316 layer->getWidth(), layer->getHeight(), layer->getFbo());
Romain Guy1fc883b2011-01-12 14:30:59 -0800317
Romain Guy09b7c912011-02-02 20:28:09 -0800318 if (!Caches::getInstance().layerCache.put(layer)) {
Romain Guyeea60692011-07-26 20:35:55 -0700319 LAYER_RENDERER_LOGD(" Destroyed!");
Chet Haase603f6de2012-09-14 15:31:25 -0700320 Caches::getInstance().resourceCache.decrementRefcount(layer);
Romain Guy09b7c912011-02-02 20:28:09 -0800321 } else {
Romain Guyeea60692011-07-26 20:35:55 -0700322 LAYER_RENDERER_LOGD(" Cached!");
Romain Guy65b345f2011-07-27 18:51:50 -0700323#if DEBUG_LAYER_RENDERER
Romain Guyeea60692011-07-26 20:35:55 -0700324 Caches::getInstance().layerCache.dump();
325#endif
Chet Haase98d3a642012-09-26 10:27:40 -0700326 layer->removeFbo();
Romain Guy09b7c912011-02-02 20:28:09 -0800327 layer->region.clear();
328 }
Romain Guyada830f2011-01-13 12:13:20 -0800329 }
Romain Guy6c319ca2011-01-11 14:29:25 -0800330}
331
Romain Guyada830f2011-01-13 12:13:20 -0800332void LayerRenderer::destroyLayerDeferred(Layer* layer) {
333 if (layer) {
Romain Guy9ace8f52011-07-07 20:50:11 -0700334 LAYER_RENDERER_LOGD("Deferring layer destruction, fbo = %d", layer->getFbo());
Dave Burke56257af2012-09-25 20:30:09 -0700335
Romain Guyada830f2011-01-13 12:13:20 -0800336 Caches::getInstance().deleteLayerDeferred(layer);
337 }
Romain Guy57066eb2011-01-12 12:53:32 -0800338}
339
Romain Guy9c4b79a2011-11-10 19:23:58 -0800340void LayerRenderer::flushLayer(Layer* layer) {
341#ifdef GL_EXT_discard_framebuffer
342 GLuint fbo = layer->getFbo();
343 if (layer && fbo) {
344 // If possible, discard any enqueud operations on deferred
345 // rendering architectures
Romain Guy3bbacf22013-02-06 16:51:04 -0800346 if (Extensions::getInstance().hasDiscardFramebuffer()) {
Romain Guy9c4b79a2011-11-10 19:23:58 -0800347 GLuint previousFbo;
348 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo);
Romain Guy9c4b79a2011-11-10 19:23:58 -0800349 if (fbo != previousFbo) glBindFramebuffer(GL_FRAMEBUFFER, fbo);
Romain Guy45e4c3d2012-09-11 17:17:07 -0700350
351 const GLenum attachments[] = { GL_COLOR_ATTACHMENT0 };
352 glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, attachments);
Romain Guy9c4b79a2011-11-10 19:23:58 -0800353
354 if (fbo != previousFbo) glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
355 }
356 }
357#endif
358}
359
Romain Guy77a81162011-06-14 16:45:55 -0700360bool LayerRenderer::copyLayer(Layer* layer, SkBitmap* bitmap) {
361 Caches& caches = Caches::getInstance();
Chris Craik710f46d2012-09-17 17:25:49 -0700362 if (layer && bitmap->width() <= caches.maxTextureSize &&
Romain Guy77a81162011-06-14 16:45:55 -0700363 bitmap->height() <= caches.maxTextureSize) {
364
365 GLuint fbo = caches.fboCache.get();
366 if (!fbo) {
Steve Block8564c8d2012-01-05 23:22:43 +0000367 ALOGW("Could not obtain an FBO");
Romain Guy77a81162011-06-14 16:45:55 -0700368 return false;
369 }
370
Romain Guyd6b2a002011-06-17 17:45:59 -0700371 SkAutoLockPixels alp(*bitmap);
372
Romain Guy77a81162011-06-14 16:45:55 -0700373 GLuint texture;
374 GLuint previousFbo;
Chris Craik710f46d2012-09-17 17:25:49 -0700375 GLuint previousViewport[4];
Romain Guy77a81162011-06-14 16:45:55 -0700376
377 GLenum format;
378 GLenum type;
379
Romain Guyd6b2a002011-06-17 17:45:59 -0700380 GLenum error = GL_NO_ERROR;
381 bool status = false;
382
Romain Guy77a81162011-06-14 16:45:55 -0700383 switch (bitmap->config()) {
384 case SkBitmap::kA8_Config:
385 format = GL_ALPHA;
386 type = GL_UNSIGNED_BYTE;
387 break;
388 case SkBitmap::kRGB_565_Config:
389 format = GL_RGB;
390 type = GL_UNSIGNED_SHORT_5_6_5;
391 break;
392 case SkBitmap::kARGB_4444_Config:
393 format = GL_RGBA;
394 type = GL_UNSIGNED_SHORT_4_4_4_4;
395 break;
396 case SkBitmap::kARGB_8888_Config:
397 default:
398 format = GL_RGBA;
399 type = GL_UNSIGNED_BYTE;
400 break;
401 }
402
Romain Guy9ace8f52011-07-07 20:50:11 -0700403 float alpha = layer->getAlpha();
404 SkXfermode::Mode mode = layer->getMode();
Chris Craik710f46d2012-09-17 17:25:49 -0700405 GLuint previousLayerFbo = layer->getFbo();
Romain Guyd6b2a002011-06-17 17:45:59 -0700406
Romain Guy9ace8f52011-07-07 20:50:11 -0700407 layer->setAlpha(255, SkXfermode::kSrc_Mode);
408 layer->setFbo(fbo);
Romain Guyd6b2a002011-06-17 17:45:59 -0700409
Romain Guy77a81162011-06-14 16:45:55 -0700410 glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &previousFbo);
Chris Craik710f46d2012-09-17 17:25:49 -0700411 glGetIntegerv(GL_VIEWPORT, (GLint*) &previousViewport);
Romain Guy77a81162011-06-14 16:45:55 -0700412 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
413
414 glGenTextures(1, &texture);
Romain Guyd6b2a002011-06-17 17:45:59 -0700415 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700416
Romain Guya1d3c912011-12-13 14:55:06 -0800417 caches.activeTexture(0);
Romain Guy8aa195d2013-06-04 18:00:09 -0700418 caches.bindTexture(texture);
Romain Guy77a81162011-06-14 16:45:55 -0700419
Romain Guye49d7ec2012-09-07 18:42:38 -0700420 glPixelStorei(GL_PACK_ALIGNMENT, bitmap->bytesPerPixel());
421
Romain Guyec19b4a2011-07-07 21:05:04 -0700422 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
423 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
Romain Guy77a81162011-06-14 16:45:55 -0700424
425 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
426 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
427
428 glTexImage2D(GL_TEXTURE_2D, 0, format, bitmap->width(), bitmap->height(),
429 0, format, type, NULL);
Romain Guyd6b2a002011-06-17 17:45:59 -0700430 if ((error = glGetError()) != GL_NO_ERROR) goto error;
431
Romain Guy77a81162011-06-14 16:45:55 -0700432 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
433 GL_TEXTURE_2D, texture, 0);
Romain Guyd6b2a002011-06-17 17:45:59 -0700434 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700435
Romain Guyd6b2a002011-06-17 17:45:59 -0700436 {
437 LayerRenderer renderer(layer);
438 renderer.setViewport(bitmap->width(), bitmap->height());
439 renderer.OpenGLRenderer::prepareDirty(0.0f, 0.0f,
Romain Guy9ace8f52011-07-07 20:50:11 -0700440 bitmap->width(), bitmap->height(), !layer->isBlend());
Romain Guya9dc86b2011-10-11 14:06:21 -0700441
Romain Guy586cae32012-07-13 15:28:31 -0700442 caches.disableScissor();
Romain Guya9dc86b2011-10-11 14:06:21 -0700443 renderer.translate(0.0f, bitmap->height());
444 renderer.scale(1.0f, -1.0f);
445
446 mat4 texTransform(layer->getTexTransform());
447
448 mat4 invert;
Romain Guy4c2547f2013-06-11 16:19:24 -0700449 invert.translate(0.0f, 1.0f);
Romain Guya9dc86b2011-10-11 14:06:21 -0700450 invert.scale(1.0f, -1.0f, 1.0f);
451 layer->getTexTransform().multiply(invert);
452
Romain Guyd6b2a002011-06-17 17:45:59 -0700453 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700454
Romain Guyd6b2a002011-06-17 17:45:59 -0700455 {
456 Rect bounds;
457 bounds.set(0.0f, 0.0f, bitmap->width(), bitmap->height());
458 renderer.drawTextureLayer(layer, bounds);
Romain Guy77a81162011-06-14 16:45:55 -0700459
Romain Guyd6b2a002011-06-17 17:45:59 -0700460 glReadPixels(0, 0, bitmap->width(), bitmap->height(), format,
461 type, bitmap->getPixels());
Romain Guy77a81162011-06-14 16:45:55 -0700462
Romain Guyd6b2a002011-06-17 17:45:59 -0700463 if ((error = glGetError()) != GL_NO_ERROR) goto error;
464 }
Romain Guy77a81162011-06-14 16:45:55 -0700465
Romain Guya9dc86b2011-10-11 14:06:21 -0700466 layer->getTexTransform().load(texTransform);
Romain Guyd6b2a002011-06-17 17:45:59 -0700467 status = true;
468 }
Romain Guy77a81162011-06-14 16:45:55 -0700469
Romain Guyd6b2a002011-06-17 17:45:59 -0700470error:
471#if DEBUG_OPENGL
472 if (error != GL_NO_ERROR) {
Steve Block5baa3a62011-12-20 16:23:08 +0000473 ALOGD("GL error while copying layer into bitmap = 0x%x", error);
Romain Guyd6b2a002011-06-17 17:45:59 -0700474 }
475#endif
Romain Guy77a81162011-06-14 16:45:55 -0700476
477 glBindFramebuffer(GL_FRAMEBUFFER, previousFbo);
Romain Guy9ace8f52011-07-07 20:50:11 -0700478 layer->setAlpha(alpha, mode);
Chris Craik710f46d2012-09-17 17:25:49 -0700479 layer->setFbo(previousLayerFbo);
Romain Guybe1b1272013-06-06 14:02:54 -0700480 caches.deleteTexture(texture);
Romain Guy77a81162011-06-14 16:45:55 -0700481 caches.fboCache.put(fbo);
Chris Craik710f46d2012-09-17 17:25:49 -0700482 glViewport(previousViewport[0], previousViewport[1],
483 previousViewport[2], previousViewport[3]);
Romain Guy77a81162011-06-14 16:45:55 -0700484
Romain Guyd6b2a002011-06-17 17:45:59 -0700485 return status;
Romain Guy77a81162011-06-14 16:45:55 -0700486 }
487 return false;
488}
489
Romain Guy6c319ca2011-01-11 14:29:25 -0800490}; // namespace uirenderer
491}; // namespace android