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