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