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