1 /*
2 * Copyright (C) 2015 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 #include "BakedOpRenderer.h"
18
19 #include "Caches.h"
20 #include "Glop.h"
21 #include "GlopBuilder.h"
22 #include "renderstate/OffscreenBufferPool.h"
23 #include "renderstate/RenderState.h"
24 #include "utils/GLUtils.h"
25 #include "VertexBuffer.h"
26
27 #include <algorithm>
28
29 namespace android {
30 namespace uirenderer {
31
startTemporaryLayer(uint32_t width,uint32_t height)32 OffscreenBuffer* BakedOpRenderer::startTemporaryLayer(uint32_t width, uint32_t height) {
33 LOG_ALWAYS_FATAL_IF(mRenderTarget.offscreenBuffer, "already has layer...");
34
35 OffscreenBuffer* buffer = mRenderState.layerPool().get(
36 mRenderState, width, height, mWideColorGamut);
37 startRepaintLayer(buffer, Rect(width, height));
38 return buffer;
39 }
40
recycleTemporaryLayer(OffscreenBuffer * offscreenBuffer)41 void BakedOpRenderer::recycleTemporaryLayer(OffscreenBuffer* offscreenBuffer) {
42 mRenderState.layerPool().putOrDelete(offscreenBuffer);
43 }
44
startRepaintLayer(OffscreenBuffer * offscreenBuffer,const Rect & repaintRect)45 void BakedOpRenderer::startRepaintLayer(OffscreenBuffer* offscreenBuffer, const Rect& repaintRect) {
46 LOG_ALWAYS_FATAL_IF(mRenderTarget.offscreenBuffer, "already has layer...");
47
48 // subtract repaintRect from region, since it will be regenerated
49 if (repaintRect.contains(0, 0,
50 offscreenBuffer->viewportWidth, offscreenBuffer->viewportHeight)) {
51 // repaint full layer, so throw away entire region
52 offscreenBuffer->region.clear();
53 } else {
54 offscreenBuffer->region.subtractSelf(android::Rect(repaintRect.left, repaintRect.top,
55 repaintRect.right, repaintRect.bottom));
56 }
57
58 mRenderTarget.offscreenBuffer = offscreenBuffer;
59 mRenderTarget.offscreenBuffer->hasRenderedSinceRepaint = false;
60
61 // create and bind framebuffer
62 mRenderTarget.frameBufferId = mRenderState.createFramebuffer();
63 mRenderState.bindFramebuffer(mRenderTarget.frameBufferId);
64
65 // attach the texture to the FBO
66 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
67 offscreenBuffer->texture.id(), 0);
68 GL_CHECKPOINT(LOW);
69
70 int status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
71 LOG_ALWAYS_FATAL_IF(status != GL_FRAMEBUFFER_COMPLETE,
72 "framebuffer incomplete, status %d, textureId %d, size %dx%d",
73 status,
74 offscreenBuffer->texture.id(),
75 offscreenBuffer->texture.width(),
76 offscreenBuffer->texture.height());
77
78 // Change the viewport & ortho projection
79 setViewport(offscreenBuffer->viewportWidth, offscreenBuffer->viewportHeight);
80
81 clearColorBuffer(repaintRect);
82 }
83
endLayer()84 void BakedOpRenderer::endLayer() {
85 if (mRenderTarget.stencil) {
86 // if stencil was used for clipping, detach it and return it to pool
87 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
88 GL_CHECKPOINT(MODERATE);
89 mCaches.renderBufferCache.put(mRenderTarget.stencil);
90 mRenderTarget.stencil = nullptr;
91 }
92 mRenderTarget.lastStencilClip = nullptr;
93
94 mRenderTarget.offscreenBuffer->updateMeshFromRegion();
95 mRenderTarget.offscreenBuffer = nullptr; // It's in drawLayerOp's hands now.
96
97 // Detach the texture from the FBO
98 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
99 GL_CHECKPOINT(LOW);
100 mRenderState.deleteFramebuffer(mRenderTarget.frameBufferId);
101 mRenderTarget.frameBufferId = 0;
102 }
103
copyToLayer(const Rect & area)104 OffscreenBuffer* BakedOpRenderer::copyToLayer(const Rect& area) {
105 const uint32_t width = area.getWidth();
106 const uint32_t height = area.getHeight();
107 OffscreenBuffer* buffer = mRenderState.layerPool().get(
108 mRenderState, width, height, mWideColorGamut);
109 if (!area.isEmpty() && width != 0 && height != 0) {
110 mCaches.textureState().activateTexture(0);
111 mCaches.textureState().bindTexture(buffer->texture.id());
112
113 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
114 area.left, mRenderTarget.viewportHeight - area.bottom, width, height);
115 }
116 return buffer;
117 }
118
startFrame(uint32_t width,uint32_t height,const Rect & repaintRect)119 void BakedOpRenderer::startFrame(uint32_t width, uint32_t height, const Rect& repaintRect) {
120 LOG_ALWAYS_FATAL_IF(mRenderTarget.frameBufferId != 0, "primary framebufferId must be 0");
121 mRenderState.bindFramebuffer(0);
122 setViewport(width, height);
123
124 if (!mOpaque) {
125 clearColorBuffer(repaintRect);
126 }
127
128 mRenderState.debugOverdraw(true, true);
129 }
130
endFrame(const Rect & repaintRect)131 void BakedOpRenderer::endFrame(const Rect& repaintRect) {
132 if (CC_UNLIKELY(Properties::debugOverdraw)) {
133 ClipRect overdrawClip(repaintRect);
134 Rect viewportRect(mRenderTarget.viewportWidth, mRenderTarget.viewportHeight);
135 // overdraw visualization
136 for (int i = 1; i <= 4; i++) {
137 if (i < 4) {
138 // nth level of overdraw tests for n+1 draws per pixel
139 mRenderState.stencil().enableDebugTest(i + 1, false);
140 } else {
141 // 4th level tests for 4 or higher draws per pixel
142 mRenderState.stencil().enableDebugTest(4, true);
143 }
144
145 SkPaint paint;
146 paint.setColor(mCaches.getOverdrawColor(i));
147 Glop glop;
148 GlopBuilder(mRenderState, mCaches, &glop)
149 .setRoundRectClipState(nullptr)
150 .setMeshUnitQuad()
151 .setFillPaint(paint, 1.0f)
152 .setTransform(Matrix4::identity(), TransformFlags::None)
153 .setModelViewMapUnitToRect(viewportRect)
154 .build();
155 renderGlop(nullptr, &overdrawClip, glop);
156 }
157 mRenderState.stencil().disable();
158 }
159
160 // Note: we leave FBO 0 renderable here, for post-frame-content decoration
161 }
162
setViewport(uint32_t width,uint32_t height)163 void BakedOpRenderer::setViewport(uint32_t width, uint32_t height) {
164 mRenderTarget.viewportWidth = width;
165 mRenderTarget.viewportHeight = height;
166 mRenderTarget.orthoMatrix.loadOrtho(width, height);
167
168 mRenderState.setViewport(width, height);
169 mRenderState.blend().syncEnabled();
170 }
171
clearColorBuffer(const Rect & rect)172 void BakedOpRenderer::clearColorBuffer(const Rect& rect) {
173 if (rect.contains(Rect(mRenderTarget.viewportWidth, mRenderTarget.viewportHeight))) {
174 // Full viewport is being cleared - disable scissor
175 mRenderState.scissor().setEnabled(false);
176 } else {
177 // Requested rect is subset of viewport - scissor to it to avoid over-clearing
178 mRenderState.scissor().setEnabled(true);
179 mRenderState.scissor().set(rect.left, mRenderTarget.viewportHeight - rect.bottom,
180 rect.getWidth(), rect.getHeight());
181 }
182 glClear(GL_COLOR_BUFFER_BIT);
183 if (!mRenderTarget.frameBufferId) mHasDrawn = true;
184 }
185
getTexture(Bitmap * bitmap)186 Texture* BakedOpRenderer::getTexture(Bitmap* bitmap) {
187 return mCaches.textureCache.get(bitmap);
188 }
189
drawRects(const float * rects,int count,const SkPaint * paint)190 void BakedOpRenderer::drawRects(const float* rects, int count, const SkPaint* paint) {
191 std::vector<Vertex> vertices;
192 vertices.reserve(count);
193 Vertex* vertex = vertices.data();
194
195 for (int index = 0; index < count; index += 4) {
196 float l = rects[index + 0];
197 float t = rects[index + 1];
198 float r = rects[index + 2];
199 float b = rects[index + 3];
200
201 Vertex::set(vertex++, l, t);
202 Vertex::set(vertex++, r, t);
203 Vertex::set(vertex++, l, b);
204 Vertex::set(vertex++, r, b);
205 }
206
207 LOG_ALWAYS_FATAL_IF(mRenderTarget.frameBufferId != 0, "decoration only supported for FBO 0");
208 // TODO: Currently assume full FBO damage, due to FrameInfoVisualizer::unionDirty.
209 // Should should scissor/set mHasDrawn safely.
210 mRenderState.scissor().setEnabled(false);
211 Glop glop;
212 GlopBuilder(mRenderState, mCaches, &glop)
213 .setRoundRectClipState(nullptr)
214 .setMeshIndexedQuads(vertices.data(), count / 4)
215 .setFillPaint(*paint, 1.0f)
216 .setTransform(Matrix4::identity(), TransformFlags::None)
217 .setModelViewIdentityEmptyBounds()
218 .build();
219 mRenderState.render(glop, mRenderTarget.orthoMatrix, false);
220 mHasDrawn = true;
221 }
222
223 // clears and re-fills stencil with provided rendertarget space quads,
224 // and then put stencil into test mode
setupStencilQuads(std::vector<Vertex> & quadVertices,int incrementThreshold)225 void BakedOpRenderer::setupStencilQuads(std::vector<Vertex>& quadVertices,
226 int incrementThreshold) {
227 mRenderState.stencil().enableWrite(incrementThreshold);
228 mRenderState.stencil().clear();
229 Glop glop;
230 GlopBuilder(mRenderState, mCaches, &glop)
231 .setRoundRectClipState(nullptr)
232 .setMeshIndexedQuads(quadVertices.data(), quadVertices.size() / 4)
233 .setFillBlack()
234 .setTransform(Matrix4::identity(), TransformFlags::None)
235 .setModelViewIdentityEmptyBounds()
236 .build();
237 mRenderState.render(glop, mRenderTarget.orthoMatrix, false);
238 mRenderState.stencil().enableTest(incrementThreshold);
239 }
240
setupStencilRectList(const ClipBase * clip)241 void BakedOpRenderer::setupStencilRectList(const ClipBase* clip) {
242 LOG_ALWAYS_FATAL_IF(clip->mode != ClipMode::RectangleList, "can't rectlist clip without rectlist");
243 auto&& rectList = reinterpret_cast<const ClipRectList*>(clip)->rectList;
244 int quadCount = rectList.getTransformedRectanglesCount();
245 std::vector<Vertex> rectangleVertices;
246 rectangleVertices.reserve(quadCount * 4);
247 for (int i = 0; i < quadCount; i++) {
248 const TransformedRectangle& tr(rectList.getTransformedRectangle(i));
249 const Matrix4& transform = tr.getTransform();
250 Rect bounds = tr.getBounds();
251 if (transform.rectToRect()) {
252 // If rectToRect, can simply map bounds before storing verts
253 transform.mapRect(bounds);
254 bounds.doIntersect(clip->rect);
255 if (bounds.isEmpty()) {
256 continue; // will be outside of scissor, skip
257 }
258 }
259
260 rectangleVertices.push_back(Vertex{bounds.left, bounds.top});
261 rectangleVertices.push_back(Vertex{bounds.right, bounds.top});
262 rectangleVertices.push_back(Vertex{bounds.left, bounds.bottom});
263 rectangleVertices.push_back(Vertex{bounds.right, bounds.bottom});
264
265 if (!transform.rectToRect()) {
266 // If not rectToRect, must map each point individually
267 for (auto cur = rectangleVertices.end() - 4; cur < rectangleVertices.end(); cur++) {
268 transform.mapPoint(cur->x, cur->y);
269 }
270 }
271 }
272 setupStencilQuads(rectangleVertices, rectList.getTransformedRectanglesCount());
273 }
274
setupStencilRegion(const ClipBase * clip)275 void BakedOpRenderer::setupStencilRegion(const ClipBase* clip) {
276 LOG_ALWAYS_FATAL_IF(clip->mode != ClipMode::Region, "can't region clip without region");
277 auto&& region = reinterpret_cast<const ClipRegion*>(clip)->region;
278
279 std::vector<Vertex> regionVertices;
280 SkRegion::Cliperator it(region, clip->rect.toSkIRect());
281 while (!it.done()) {
282 const SkIRect& r = it.rect();
283 regionVertices.push_back(Vertex{(float)r.fLeft, (float)r.fTop});
284 regionVertices.push_back(Vertex{(float)r.fRight, (float)r.fTop});
285 regionVertices.push_back(Vertex{(float)r.fLeft, (float)r.fBottom});
286 regionVertices.push_back(Vertex{(float)r.fRight, (float)r.fBottom});
287 it.next();
288 }
289 setupStencilQuads(regionVertices, 0);
290 }
291
prepareRender(const Rect * dirtyBounds,const ClipBase * clip)292 void BakedOpRenderer::prepareRender(const Rect* dirtyBounds, const ClipBase* clip) {
293 // Prepare scissor (done before stencil, to simplify filling stencil)
294 mRenderState.scissor().setEnabled(clip != nullptr);
295 if (clip) {
296 mRenderState.scissor().set(mRenderTarget.viewportHeight, clip->rect);
297 }
298
299 // If stencil may be used for clipping, enable it, fill it, or disable it as appropriate
300 if (CC_LIKELY(!Properties::debugOverdraw)) {
301 // only modify stencil mode and content when it's not used for overdraw visualization
302 if (CC_UNLIKELY(clip && clip->mode != ClipMode::Rectangle)) {
303 // NOTE: this pointer check is only safe for non-rect clips,
304 // since rect clips may be created on the stack
305 if (mRenderTarget.lastStencilClip != clip) {
306 // Stencil needed, but current stencil isn't up to date
307 mRenderTarget.lastStencilClip = clip;
308
309 if (mRenderTarget.frameBufferId != 0 && !mRenderTarget.stencil) {
310 OffscreenBuffer* layer = mRenderTarget.offscreenBuffer;
311 mRenderTarget.stencil = mCaches.renderBufferCache.get(
312 Stencil::getLayerStencilFormat(),
313 layer->texture.width(), layer->texture.height());
314 // stencil is bound + allocated - associate it with current FBO
315 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
316 GL_RENDERBUFFER, mRenderTarget.stencil->getName());
317 }
318
319 if (clip->mode == ClipMode::RectangleList) {
320 setupStencilRectList(clip);
321 } else {
322 setupStencilRegion(clip);
323 }
324 } else {
325 // stencil is up to date - just need to ensure it's enabled (since an unclipped
326 // or scissor-only clipped op may have been drawn, disabling the stencil)
327 int incrementThreshold = 0;
328 if (CC_LIKELY(clip->mode == ClipMode::RectangleList)) {
329 auto&& rectList = reinterpret_cast<const ClipRectList*>(clip)->rectList;
330 incrementThreshold = rectList.getTransformedRectanglesCount();
331 }
332 mRenderState.stencil().enableTest(incrementThreshold);
333 }
334 } else {
335 // either scissor or no clip, so disable stencil test
336 mRenderState.stencil().disable();
337 }
338 }
339
340 if (dirtyBounds) {
341 // dirty offscreenbuffer if present
342 dirtyRenderTarget(*dirtyBounds);
343 }
344 }
345
renderGlopImpl(const Rect * dirtyBounds,const ClipBase * clip,const Glop & glop)346 void BakedOpRenderer::renderGlopImpl(const Rect* dirtyBounds, const ClipBase* clip,
347 const Glop& glop) {
348 prepareRender(dirtyBounds, clip);
349 // Disable blending if this is the first draw to the main framebuffer, in case app has defined
350 // transparency where it doesn't make sense - as first draw in opaque window. Note that we only
351 // apply this improvement when the blend mode is SRC_OVER - other modes (e.g. CLEAR) can be
352 // valid draws that affect other content (e.g. draw CLEAR, then draw DST_OVER)
353 bool overrideDisableBlending = !mHasDrawn
354 && mOpaque
355 && !mRenderTarget.frameBufferId
356 && glop.blend.src == GL_ONE
357 && glop.blend.dst == GL_ONE_MINUS_SRC_ALPHA;
358 mRenderState.render(glop, mRenderTarget.orthoMatrix, overrideDisableBlending);
359 if (!mRenderTarget.frameBufferId) mHasDrawn = true;
360 }
361
renderFunctor(const FunctorOp & op,const BakedOpState & state)362 void BakedOpRenderer::renderFunctor(const FunctorOp& op, const BakedOpState& state) {
363 prepareRender(&state.computedState.clippedBounds, state.computedState.getClipIfNeeded());
364
365 DrawGlInfo info;
366 auto&& clip = state.computedState.clipRect();
367 info.clipLeft = clip.left;
368 info.clipTop = clip.top;
369 info.clipRight = clip.right;
370 info.clipBottom = clip.bottom;
371 info.isLayer = offscreenRenderTarget();
372 info.width = mRenderTarget.viewportWidth;
373 info.height = mRenderTarget.viewportHeight;
374 state.computedState.transform.copyTo(&info.transform[0]);
375
376 mRenderState.invokeFunctor(op.functor, DrawGlInfo::kModeDraw, &info);
377 if (!mRenderTarget.frameBufferId) mHasDrawn = true;
378 }
379
dirtyRenderTarget(const Rect & uiDirty)380 void BakedOpRenderer::dirtyRenderTarget(const Rect& uiDirty) {
381 if (mRenderTarget.offscreenBuffer) {
382 mRenderTarget.offscreenBuffer->dirty(uiDirty);
383 }
384 }
385
386 } // namespace uirenderer
387 } // namespace android
388