blob: 83f9c6a0743746bd6f47967b93537d857b10ff02 [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"
John Reckec4cefc2014-07-29 09:49:13 -070018#define ATRACE_TAG ATRACE_TAG_VIEW
Romain Guy6c319ca2011-01-11 14:29:25 -080019
Romain Guy3a3133d2011-02-01 22:59:58 -080020#include <ui/Rect.h>
21
Romain Guy7c25aab2012-10-18 15:05:02 -070022#include <private/hwui/DrawGlInfo.h>
23
John Reck3b202512014-06-23 13:13:08 -070024#include "RenderState.h"
Romain Guy09b7c912011-02-02 20:28:09 -080025#include "LayerCache.h"
Romain Guy6c319ca2011-01-11 14:29:25 -080026#include "LayerRenderer.h"
Romain Guyaa6c24c2011-04-28 18:40:04 -070027#include "Matrix.h"
Romain Guy1fc883b2011-01-12 14:30:59 -080028#include "Properties.h"
Romain Guy3a3133d2011-02-01 22:59:58 -080029#include "Rect.h"
Chris Craik70850ea2014-11-18 10:49:23 -080030#include "utils/TraceUtils.h"
Romain Guy6c319ca2011-01-11 14:29:25 -080031
32namespace android {
33namespace uirenderer {
34
35///////////////////////////////////////////////////////////////////////////////
36// Rendering
37///////////////////////////////////////////////////////////////////////////////
38
John Reck3b202512014-06-23 13:13:08 -070039LayerRenderer::LayerRenderer(RenderState& renderState, Layer* layer)
40 : OpenGLRenderer(renderState)
41 , mLayer(layer) {
Romain Guy79537452011-10-12 13:48:51 -070042}
43
44LayerRenderer::~LayerRenderer() {
45}
46
Romain Guy7c25aab2012-10-18 15:05:02 -070047status_t LayerRenderer::prepareDirty(float left, float top, float right, float bottom,
48 bool opaque) {
Romain Guy9ace8f52011-07-07 20:50:11 -070049 LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->getFbo());
Romain Guy1fc883b2011-01-12 14:30:59 -080050
John Reck3b202512014-06-23 13:13:08 -070051 renderState().bindFramebuffer(mLayer->getFbo());
Romain Guy62687ec2011-02-02 15:44:19 -080052
Romain Guy09b7c912011-02-02 20:28:09 -080053 const float width = mLayer->layer.getWidth();
54 const float height = mLayer->layer.getHeight();
55
Romain Guy3a3133d2011-02-01 22:59:58 -080056 Rect dirty(left, top, right, bottom);
57 if (dirty.isEmpty() || (dirty.left <= 0 && dirty.top <= 0 &&
Romain Guy09b7c912011-02-02 20:28:09 -080058 dirty.right >= width && dirty.bottom >= height)) {
Romain Guy3a3133d2011-02-01 22:59:58 -080059 mLayer->region.clear();
Romain Guy09b7c912011-02-02 20:28:09 -080060 dirty.set(0.0f, 0.0f, width, height);
Romain Guy3a3133d2011-02-01 22:59:58 -080061 } else {
Romain Guy09b7c912011-02-02 20:28:09 -080062 dirty.intersect(0.0f, 0.0f, width, height);
Romain Guy3a3133d2011-02-01 22:59:58 -080063 android::Rect r(dirty.left, dirty.top, dirty.right, dirty.bottom);
64 mLayer->region.subtractSelf(r);
65 }
Romain Guyc3fedaf2013-01-29 17:26:25 -080066 mLayer->clipRect.set(dirty);
Romain Guyc88e3572011-01-22 00:32:12 -080067
Chet Haase44b2fe32012-06-06 19:03:58 -070068 return OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);
Romain Guy6c319ca2011-01-11 14:29:25 -080069}
70
Romain Guy7c25aab2012-10-18 15:05:02 -070071status_t LayerRenderer::clear(float left, float top, float right, float bottom, bool opaque) {
72 if (mLayer->isDirty()) {
73 getCaches().disableScissor();
74 glClear(GL_COLOR_BUFFER_BIT);
75
76 getCaches().resetScissor();
77 mLayer->setDirty(false);
78
79 return DrawGlInfo::kStatusDone;
80 }
81
82 return OpenGLRenderer::clear(left, top, right, bottom, opaque);
83}
84
Romain Guy6c319ca2011-01-11 14:29:25 -080085void LayerRenderer::finish() {
86 OpenGLRenderer::finish();
Romain Guy1fc883b2011-01-12 14:30:59 -080087
Romain Guyf219da52011-01-16 12:54:25 -080088 generateMesh();
89
Romain Guy9ace8f52011-07-07 20:50:11 -070090 LAYER_RENDERER_LOGD("Finished rendering into layer, fbo = %d", mLayer->getFbo());
Romain Guy42f3a4b2011-01-19 13:42:26 -080091
92 // No need to unbind our FBO, this will be taken care of by the caller
93 // who will invoke OpenGLRenderer::resume()
94}
95
Chris Craik14e51302013-12-30 15:32:54 -080096GLuint LayerRenderer::getTargetFbo() const {
Romain Guy9ace8f52011-07-07 20:50:11 -070097 return mLayer->getFbo();
Romain Guy6c319ca2011-01-11 14:29:25 -080098}
99
Romain Guy624234f2013-03-05 16:43:31 -0800100bool LayerRenderer::suppressErrorChecks() const {
Romain Guy11cb6422012-09-21 00:39:43 -0700101 return true;
102}
103
Romain Guy6c319ca2011-01-11 14:29:25 -0800104///////////////////////////////////////////////////////////////////////////////
Romain Guy8ce00302013-01-15 18:51:42 -0800105// Layer support
Romain Guyf219da52011-01-16 12:54:25 -0800106///////////////////////////////////////////////////////////////////////////////
107
Romain Guy624234f2013-03-05 16:43:31 -0800108bool LayerRenderer::hasLayer() const {
Romain Guyf219da52011-01-16 12:54:25 -0800109 return true;
110}
111
Romain Guy8ce00302013-01-15 18:51:42 -0800112void LayerRenderer::ensureStencilBuffer() {
113 attachStencilBufferToLayer(mLayer);
114}
115
116///////////////////////////////////////////////////////////////////////////////
117// Dirty region tracking
118///////////////////////////////////////////////////////////////////////////////
119
Romain Guy624234f2013-03-05 16:43:31 -0800120Region* LayerRenderer::getRegion() const {
Chris Craikd6b65f62014-01-01 14:45:21 -0800121 if (currentSnapshot()->flags & Snapshot::kFlagFboTarget) {
Romain Guyf219da52011-01-16 12:54:25 -0800122 return OpenGLRenderer::getRegion();
123 }
124 return &mLayer->region;
Romain Guyf219da52011-01-16 12:54:25 -0800125}
126
Chris Craik6c5b9be2013-02-27 14:03:19 -0800127// TODO: This implementation uses a very simple approach to fixing T-junctions which keeps the
128// results as rectangles, and is thus not necessarily efficient in the geometry
129// produced. Eventually, it may be better to develop triangle-based mechanism.
Romain Guyf219da52011-01-16 12:54:25 -0800130void LayerRenderer::generateMesh() {
Romain Guyf219da52011-01-16 12:54:25 -0800131 if (mLayer->region.isRect() || mLayer->region.isEmpty()) {
132 if (mLayer->mesh) {
Romain Guy96885eb2013-03-26 15:05:58 -0700133 delete[] mLayer->mesh;
Romain Guyf219da52011-01-16 12:54:25 -0800134 mLayer->mesh = NULL;
Romain Guyf219da52011-01-16 12:54:25 -0800135 mLayer->meshElementCount = 0;
136 }
Romain Guy40667672011-03-18 14:34:03 -0700137
Romain Guy9fc27812011-04-27 14:21:41 -0700138 mLayer->setRegionAsRect();
Romain Guyf219da52011-01-16 12:54:25 -0800139 return;
140 }
141
Chris Craik6c5b9be2013-02-27 14:03:19 -0800142 // avoid T-junctions as they cause artifacts in between the resultant
143 // geometry when complex transforms occur.
144 // TODO: generate the safeRegion only if necessary based on drawing transform (see
145 // OpenGLRenderer::composeLayerRegion())
146 Region safeRegion = Region::createTJunctionFreeRegion(mLayer->region);
147
Romain Guyf219da52011-01-16 12:54:25 -0800148 size_t count;
Chris Craik6c5b9be2013-02-27 14:03:19 -0800149 const android::Rect* rects = safeRegion.getArray(&count);
Romain Guyf219da52011-01-16 12:54:25 -0800150
151 GLsizei elementCount = count * 6;
152
153 if (mLayer->mesh && mLayer->meshElementCount < elementCount) {
Romain Guy96885eb2013-03-26 15:05:58 -0700154 delete[] mLayer->mesh;
Romain Guyf219da52011-01-16 12:54:25 -0800155 mLayer->mesh = NULL;
Romain Guyf219da52011-01-16 12:54:25 -0800156 }
157
158 if (!mLayer->mesh) {
159 mLayer->mesh = new TextureVertex[count * 4];
Romain Guyf219da52011-01-16 12:54:25 -0800160 }
Romain Guy4f09f542011-01-26 22:41:43 -0800161 mLayer->meshElementCount = elementCount;
Romain Guyf219da52011-01-16 12:54:25 -0800162
Romain Guy9ace8f52011-07-07 20:50:11 -0700163 const float texX = 1.0f / float(mLayer->getWidth());
164 const float texY = 1.0f / float(mLayer->getHeight());
Romain Guyf219da52011-01-16 12:54:25 -0800165 const float height = mLayer->layer.getHeight();
166
167 TextureVertex* mesh = mLayer->mesh;
Romain Guyf219da52011-01-16 12:54:25 -0800168
169 for (size_t i = 0; i < count; i++) {
170 const android::Rect* r = &rects[i];
171
172 const float u1 = r->left * texX;
173 const float v1 = (height - r->top) * texY;
174 const float u2 = r->right * texX;
175 const float v2 = (height - r->bottom) * texY;
176
177 TextureVertex::set(mesh++, r->left, r->top, u1, v1);
178 TextureVertex::set(mesh++, r->right, r->top, u2, v1);
179 TextureVertex::set(mesh++, r->left, r->bottom, u1, v2);
180 TextureVertex::set(mesh++, r->right, r->bottom, u2, v2);
Romain Guyf219da52011-01-16 12:54:25 -0800181 }
Romain Guyf219da52011-01-16 12:54:25 -0800182}
183
184///////////////////////////////////////////////////////////////////////////////
185// Layers management
Romain Guy6c319ca2011-01-11 14:29:25 -0800186///////////////////////////////////////////////////////////////////////////////
187
John Reck3b202512014-06-23 13:13:08 -0700188Layer* LayerRenderer::createRenderLayer(RenderState& renderState, uint32_t width, uint32_t height) {
Chris Craik70850ea2014-11-18 10:49:23 -0800189 ATRACE_FORMAT("Allocate %ux%u HW Layer", width, height);
Romain Guyeea60692011-07-26 20:35:55 -0700190 LAYER_RENDERER_LOGD("Requesting new render layer %dx%d", width, height);
Romain Guy1fc883b2011-01-12 14:30:59 -0800191
Romain Guya1d3c912011-12-13 14:55:06 -0800192 Caches& caches = Caches::getInstance();
193 GLuint fbo = caches.fboCache.get();
Romain Guy09b7c912011-02-02 20:28:09 -0800194 if (!fbo) {
Steve Block8564c8d2012-01-05 23:22:43 +0000195 ALOGW("Could not obtain an FBO");
Romain Guy09b7c912011-02-02 20:28:09 -0800196 return NULL;
197 }
198
Romain Guya1d3c912011-12-13 14:55:06 -0800199 caches.activeTexture(0);
John Reck3b202512014-06-23 13:13:08 -0700200 Layer* layer = caches.layerCache.get(renderState, width, height);
Romain Guy09b7c912011-02-02 20:28:09 -0800201 if (!layer) {
Steve Block8564c8d2012-01-05 23:22:43 +0000202 ALOGW("Could not obtain a layer");
Romain Guy09b7c912011-02-02 20:28:09 -0800203 return NULL;
204 }
205
Romain Guyce4a7df2013-03-28 11:32:33 -0700206 // We first obtain a layer before comparing against the max texture size
207 // because layers are not allocated at the exact desired size. They are
208 // always created slighly larger to improve recycling
209 const uint32_t maxTextureSize = caches.maxTextureSize;
210 if (layer->getWidth() > maxTextureSize || layer->getHeight() > maxTextureSize) {
211 ALOGW("Layer exceeds max. dimensions supported by the GPU (%dx%d, max=%dx%d)",
212 width, height, maxTextureSize, maxTextureSize);
213
214 // Creating a new layer always increment its refcount by 1, this allows
215 // us to destroy the layer object if one was created for us
John Reck0e89e2b2014-10-31 14:49:06 -0700216 layer->decStrong(0);
Romain Guyce4a7df2013-03-28 11:32:33 -0700217
218 return NULL;
219 }
220
Romain Guy9ace8f52011-07-07 20:50:11 -0700221 layer->setFbo(fbo);
Romain Guy09b7c912011-02-02 20:28:09 -0800222 layer->layer.set(0.0f, 0.0f, width, height);
Romain Guy9ace8f52011-07-07 20:50:11 -0700223 layer->texCoords.set(0.0f, height / float(layer->getHeight()),
224 width / float(layer->getWidth()), 0.0f);
225 layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
Romain Guy9ace8f52011-07-07 20:50:11 -0700226 layer->setColorFilter(NULL);
Romain Guy7c25aab2012-10-18 15:05:02 -0700227 layer->setDirty(true);
Romain Guy09b7c912011-02-02 20:28:09 -0800228 layer->region.clear();
Romain Guyada830f2011-01-13 12:13:20 -0800229
John Reck3b202512014-06-23 13:13:08 -0700230 GLuint previousFbo = renderState.getFramebuffer();
Romain Guy6c319ca2011-01-11 14:29:25 -0800231
John Reck3b202512014-06-23 13:13:08 -0700232 renderState.bindFramebuffer(layer->getFbo());
Romain Guy9ace8f52011-07-07 20:50:11 -0700233 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);
John Reck3b202512014-06-23 13:13:08 -0700243 renderState.bindFramebuffer(previousFbo);
John Reck0e89e2b2014-10-31 14:49:06 -0700244 layer->decStrong(0);
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
John Reck3b202512014-06-23 13:13:08 -0700252 renderState.bindFramebuffer(previousFbo);
Romain Guy6c319ca2011-01-11 14:29:25 -0800253
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
John Reck3b202512014-06-23 13:13:08 -0700273Layer* LayerRenderer::createTextureLayer(RenderState& renderState) {
Romain Guy4a5a7152011-06-24 17:53:53 -0700274 LAYER_RENDERER_LOGD("Creating new texture layer");
275
Chris Craik8a226d22014-09-08 16:40:21 -0700276 Layer* layer = new Layer(Layer::kType_Texture, renderState, 0, 0);
Romain Guy9ace8f52011-07-07 20:50:11 -0700277 layer->setCacheable(false);
Romain Guy9ace8f52011-07-07 20:50:11 -0700278 layer->setEmpty(true);
279 layer->setFbo(0);
280 layer->setAlpha(255, SkXfermode::kSrcOver_Mode);
Romain Guy4a5a7152011-06-24 17:53:53 -0700281 layer->layer.set(0.0f, 0.0f, 0.0f, 0.0f);
Romain Guya9dc86b2011-10-11 14:06:21 -0700282 layer->texCoords.set(0.0f, 1.0f, 1.0f, 0.0f);
Romain Guy4a5a7152011-06-24 17:53:53 -0700283 layer->region.clear();
Romain Guy9ace8f52011-07-07 20:50:11 -0700284 layer->setRenderTarget(GL_NONE); // see ::updateTextureLayer()
Romain Guy4a5a7152011-06-24 17:53:53 -0700285
Romain Guya1d3c912011-12-13 14:55:06 -0800286 Caches::getInstance().activeTexture(0);
Romain Guy9ace8f52011-07-07 20:50:11 -0700287 layer->generateTexture();
Romain Guy4a5a7152011-06-24 17:53:53 -0700288
289 return layer;
290}
291
Romain Guyaa6c24c2011-04-28 18:40:04 -0700292void LayerRenderer::updateTextureLayer(Layer* layer, uint32_t width, uint32_t height,
Chris Craik9757ac02014-02-25 18:50:17 -0800293 bool isOpaque, bool forceFilter, GLenum renderTarget, float* textureTransform) {
Romain Guyaa6c24c2011-04-28 18:40:04 -0700294 if (layer) {
Romain Guy9ace8f52011-07-07 20:50:11 -0700295 layer->setBlend(!isOpaque);
Chris Craik9757ac02014-02-25 18:50:17 -0800296 layer->setForceFilter(forceFilter);
Romain Guy9ace8f52011-07-07 20:50:11 -0700297 layer->setSize(width, height);
Romain Guyaa6c24c2011-04-28 18:40:04 -0700298 layer->layer.set(0.0f, 0.0f, width, height);
299 layer->region.set(width, height);
300 layer->regionRect.set(0.0f, 0.0f, width, height);
Chris Craik9757ac02014-02-25 18:50:17 -0800301 layer->getTexTransform().load(textureTransform);
Romain Guy8f0095c2011-05-02 17:24:22 -0700302
Romain Guy9ace8f52011-07-07 20:50:11 -0700303 if (renderTarget != layer->getRenderTarget()) {
304 layer->setRenderTarget(renderTarget);
305 layer->bindTexture();
Romain Guyd21b6e12011-11-30 20:21:23 -0800306 layer->setFilter(GL_NEAREST, false, true);
307 layer->setWrap(GL_CLAMP_TO_EDGE, false, true);
Romain Guy4a5a7152011-06-24 17:53:53 -0700308 }
Romain Guyaa6c24c2011-04-28 18:40:04 -0700309 }
310}
311
Romain Guyada830f2011-01-13 12:13:20 -0800312void LayerRenderer::destroyLayer(Layer* layer) {
313 if (layer) {
Chris Craik70850ea2014-11-18 10:49:23 -0800314 ATRACE_FORMAT("Destroy %ux%u HW Layer", layer->getWidth(), layer->getHeight());
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!");
John Reck0e89e2b2014-10-31 14:49:06 -0700320 layer->decStrong(0);
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
John Reck3b202512014-06-23 13:13:08 -0700332void LayerRenderer::flushLayer(RenderState& renderState, Layer* layer) {
Romain Guy9c4b79a2011-11-10 19:23:58 -0800333#ifdef GL_EXT_discard_framebuffer
Digish Pandya1fa4cef2014-06-12 10:42:54 +0530334 if (!layer) return;
335
Romain Guy9c4b79a2011-11-10 19:23:58 -0800336 GLuint fbo = layer->getFbo();
Digish Pandya1fa4cef2014-06-12 10:42:54 +0530337 if (fbo) {
Romain Guy9c4b79a2011-11-10 19:23:58 -0800338 // If possible, discard any enqueud operations on deferred
339 // rendering architectures
Romain Guy3bbacf22013-02-06 16:51:04 -0800340 if (Extensions::getInstance().hasDiscardFramebuffer()) {
John Reck3b202512014-06-23 13:13:08 -0700341 GLuint previousFbo = renderState.getFramebuffer();
342 if (fbo != previousFbo) {
343 renderState.bindFramebuffer(fbo);
344 }
Romain Guy45e4c3d2012-09-11 17:17:07 -0700345
346 const GLenum attachments[] = { GL_COLOR_ATTACHMENT0 };
347 glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, attachments);
Romain Guy9c4b79a2011-11-10 19:23:58 -0800348
John Reck3b202512014-06-23 13:13:08 -0700349 if (fbo != previousFbo) {
350 renderState.bindFramebuffer(previousFbo);
351 }
Romain Guy9c4b79a2011-11-10 19:23:58 -0800352 }
353 }
354#endif
355}
356
John Reck3b202512014-06-23 13:13:08 -0700357bool LayerRenderer::copyLayer(RenderState& renderState, Layer* layer, SkBitmap* bitmap) {
Romain Guy77a81162011-06-14 16:45:55 -0700358 Caches& caches = Caches::getInstance();
Chris Craik710f46d2012-09-17 17:25:49 -0700359 if (layer && bitmap->width() <= caches.maxTextureSize &&
Romain Guy77a81162011-06-14 16:45:55 -0700360 bitmap->height() <= caches.maxTextureSize) {
361
362 GLuint fbo = caches.fboCache.get();
363 if (!fbo) {
Steve Block8564c8d2012-01-05 23:22:43 +0000364 ALOGW("Could not obtain an FBO");
Romain Guy77a81162011-06-14 16:45:55 -0700365 return false;
366 }
367
Romain Guyd6b2a002011-06-17 17:45:59 -0700368 SkAutoLockPixels alp(*bitmap);
369
Romain Guy77a81162011-06-14 16:45:55 -0700370 GLuint texture;
371 GLuint previousFbo;
John Reck3b202512014-06-23 13:13:08 -0700372 GLsizei previousViewportWidth;
373 GLsizei previousViewportHeight;
Romain Guy77a81162011-06-14 16:45:55 -0700374
375 GLenum format;
376 GLenum type;
377
Romain Guyd6b2a002011-06-17 17:45:59 -0700378 GLenum error = GL_NO_ERROR;
379 bool status = false;
380
Mike Reed1103b322014-07-08 12:36:44 -0400381 switch (bitmap->colorType()) {
382 case kAlpha_8_SkColorType:
Romain Guy77a81162011-06-14 16:45:55 -0700383 format = GL_ALPHA;
384 type = GL_UNSIGNED_BYTE;
385 break;
Mike Reed1103b322014-07-08 12:36:44 -0400386 case kRGB_565_SkColorType:
Romain Guy77a81162011-06-14 16:45:55 -0700387 format = GL_RGB;
388 type = GL_UNSIGNED_SHORT_5_6_5;
389 break;
Mike Reed1103b322014-07-08 12:36:44 -0400390 case kARGB_4444_SkColorType:
Romain Guy77a81162011-06-14 16:45:55 -0700391 format = GL_RGBA;
392 type = GL_UNSIGNED_SHORT_4_4_4_4;
393 break;
Mike Reed1103b322014-07-08 12:36:44 -0400394 case kN32_SkColorType:
Romain Guy77a81162011-06-14 16:45:55 -0700395 default:
396 format = GL_RGBA;
397 type = GL_UNSIGNED_BYTE;
398 break;
399 }
400
Romain Guy9ace8f52011-07-07 20:50:11 -0700401 float alpha = layer->getAlpha();
402 SkXfermode::Mode mode = layer->getMode();
Chris Craik710f46d2012-09-17 17:25:49 -0700403 GLuint previousLayerFbo = layer->getFbo();
Romain Guyd6b2a002011-06-17 17:45:59 -0700404
Romain Guy9ace8f52011-07-07 20:50:11 -0700405 layer->setAlpha(255, SkXfermode::kSrc_Mode);
406 layer->setFbo(fbo);
Romain Guyd6b2a002011-06-17 17:45:59 -0700407
John Reck3b202512014-06-23 13:13:08 -0700408 previousFbo = renderState.getFramebuffer();
409 renderState.getViewport(&previousViewportWidth, &previousViewportHeight);
410 renderState.bindFramebuffer(fbo);
Romain Guy77a81162011-06-14 16:45:55 -0700411
412 glGenTextures(1, &texture);
Romain Guyd6b2a002011-06-17 17:45:59 -0700413 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700414
Romain Guya1d3c912011-12-13 14:55:06 -0800415 caches.activeTexture(0);
Romain Guy8aa195d2013-06-04 18:00:09 -0700416 caches.bindTexture(texture);
Romain Guy77a81162011-06-14 16:45:55 -0700417
Romain Guye49d7ec2012-09-07 18:42:38 -0700418 glPixelStorei(GL_PACK_ALIGNMENT, bitmap->bytesPerPixel());
419
Romain Guyec19b4a2011-07-07 21:05:04 -0700420 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
421 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
Romain Guy77a81162011-06-14 16:45:55 -0700422
423 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
424 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
425
426 glTexImage2D(GL_TEXTURE_2D, 0, format, bitmap->width(), bitmap->height(),
427 0, format, type, NULL);
Romain Guyd6b2a002011-06-17 17:45:59 -0700428 if ((error = glGetError()) != GL_NO_ERROR) goto error;
429
Romain Guy77a81162011-06-14 16:45:55 -0700430 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
431 GL_TEXTURE_2D, texture, 0);
Romain Guyd6b2a002011-06-17 17:45:59 -0700432 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700433
Romain Guyd6b2a002011-06-17 17:45:59 -0700434 {
John Reck3b202512014-06-23 13:13:08 -0700435 LayerRenderer renderer(renderState, layer);
Romain Guyd6b2a002011-06-17 17:45:59 -0700436 renderer.setViewport(bitmap->width(), bitmap->height());
437 renderer.OpenGLRenderer::prepareDirty(0.0f, 0.0f,
Romain Guy9ace8f52011-07-07 20:50:11 -0700438 bitmap->width(), bitmap->height(), !layer->isBlend());
Romain Guya9dc86b2011-10-11 14:06:21 -0700439
Romain Guy586cae32012-07-13 15:28:31 -0700440 caches.disableScissor();
Romain Guya9dc86b2011-10-11 14:06:21 -0700441 renderer.translate(0.0f, bitmap->height());
442 renderer.scale(1.0f, -1.0f);
443
444 mat4 texTransform(layer->getTexTransform());
445
446 mat4 invert;
Romain Guy4c2547f2013-06-11 16:19:24 -0700447 invert.translate(0.0f, 1.0f);
Romain Guya9dc86b2011-10-11 14:06:21 -0700448 invert.scale(1.0f, -1.0f, 1.0f);
449 layer->getTexTransform().multiply(invert);
450
Romain Guyd6b2a002011-06-17 17:45:59 -0700451 if ((error = glGetError()) != GL_NO_ERROR) goto error;
Romain Guy77a81162011-06-14 16:45:55 -0700452
Romain Guyd6b2a002011-06-17 17:45:59 -0700453 {
454 Rect bounds;
455 bounds.set(0.0f, 0.0f, bitmap->width(), bitmap->height());
456 renderer.drawTextureLayer(layer, bounds);
Romain Guy77a81162011-06-14 16:45:55 -0700457
Romain Guyd6b2a002011-06-17 17:45:59 -0700458 glReadPixels(0, 0, bitmap->width(), bitmap->height(), format,
459 type, bitmap->getPixels());
Romain Guy77a81162011-06-14 16:45:55 -0700460
Romain Guyd6b2a002011-06-17 17:45:59 -0700461 if ((error = glGetError()) != GL_NO_ERROR) goto error;
462 }
Romain Guy77a81162011-06-14 16:45:55 -0700463
Romain Guya9dc86b2011-10-11 14:06:21 -0700464 layer->getTexTransform().load(texTransform);
Romain Guyd6b2a002011-06-17 17:45:59 -0700465 status = true;
466 }
Romain Guy77a81162011-06-14 16:45:55 -0700467
Romain Guyd6b2a002011-06-17 17:45:59 -0700468error:
469#if DEBUG_OPENGL
470 if (error != GL_NO_ERROR) {
Steve Block5baa3a62011-12-20 16:23:08 +0000471 ALOGD("GL error while copying layer into bitmap = 0x%x", error);
Romain Guyd6b2a002011-06-17 17:45:59 -0700472 }
473#endif
Romain Guy77a81162011-06-14 16:45:55 -0700474
John Reck3b202512014-06-23 13:13:08 -0700475 renderState.bindFramebuffer(previousFbo);
Romain Guy9ace8f52011-07-07 20:50:11 -0700476 layer->setAlpha(alpha, mode);
Chris Craik710f46d2012-09-17 17:25:49 -0700477 layer->setFbo(previousLayerFbo);
Romain Guybe1b1272013-06-06 14:02:54 -0700478 caches.deleteTexture(texture);
Romain Guy77a81162011-06-14 16:45:55 -0700479 caches.fboCache.put(fbo);
John Reck3b202512014-06-23 13:13:08 -0700480 renderState.setViewport(previousViewportWidth, previousViewportHeight);
Romain Guy77a81162011-06-14 16:45:55 -0700481
Romain Guyd6b2a002011-06-17 17:45:59 -0700482 return status;
Romain Guy77a81162011-06-14 16:45:55 -0700483 }
484 return false;
485}
486
Romain Guy6c319ca2011-01-11 14:29:25 -0800487}; // namespace uirenderer
488}; // namespace android