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