libs/hwui/BakedOpRenderer.cpp

   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
  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
  40 void BakedOpRenderer::recycleTemporaryLayer(OffscreenBuffer* offscreenBuffer) {
  41     mRenderState.layerPool().putOrDelete(offscreenBuffer);
  42 }
  43
  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
  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
 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
 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
 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
 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
 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
 184 Texture* BakedOpRenderer::getTexture(const SkBitmap* bitmap) {
 185     Texture* texture = mRenderState.assetAtlas().getEntryTexture(bitmap->pixelRef());
 186     if (!texture) {
 187         return mCaches.textureCache.get(bitmap);
 188     }
 189     return texture;
 190 }
 191
 192 void BakedOpRenderer::drawRects(const float* rects, int count, const SkPaint* paint) {
 193     std::vector<Vertex> vertices;
 194     vertices.reserve(count);
 195     Vertex* vertex = vertices.data();
 196
 197     for (int index = 0; index < count; index += 4) {
 198         float l = rects[index + 0];
 199         float t = rects[index + 1];
 200         float r = rects[index + 2];
 201         float b = rects[index + 3];
 202
 203         Vertex::set(vertex++, l, t);
 204         Vertex::set(vertex++, r, t);
 205         Vertex::set(vertex++, l, b);
 206         Vertex::set(vertex++, r, b);
 207     }
 208
 209     LOG_ALWAYS_FATAL_IF(mRenderTarget.frameBufferId != 0, "decoration only supported for FBO 0");
 210     // TODO: Currently assume full FBO damage, due to FrameInfoVisualizer::unionDirty.
 211     // Should should scissor/set mHasDrawn safely.
 212     mRenderState.scissor().setEnabled(false);
 213     mHasDrawn = true;
 214     Glop glop;
 215     GlopBuilder(mRenderState, mCaches, &glop)
 216             .setRoundRectClipState(nullptr)
 217             .setMeshIndexedQuads(vertices.data(), count / 4)
 218             .setFillPaint(*paint, 1.0f)
 219             .setTransform(Matrix4::identity(), TransformFlags::None)
 220             .setModelViewIdentityEmptyBounds()
 221             .build();
 222     mRenderState.render(glop, mRenderTarget.orthoMatrix);
 223 }
 224
 225 // clears and re-fills stencil with provided rendertarget space quads,
 226 // and then put stencil into test mode
 227 void BakedOpRenderer::setupStencilQuads(std::vector<Vertex>& quadVertices,
 228         int incrementThreshold) {
 229     mRenderState.stencil().enableWrite(incrementThreshold);
 230     mRenderState.stencil().clear();
 231     Glop glop;
 232     GlopBuilder(mRenderState, mCaches, &glop)
 233             .setRoundRectClipState(nullptr)
 234             .setMeshIndexedQuads(quadVertices.data(), quadVertices.size() / 4)
 235             .setFillBlack()
 236             .setTransform(Matrix4::identity(), TransformFlags::None)
 237             .setModelViewIdentityEmptyBounds()
 238             .build();
 239     mRenderState.render(glop, mRenderTarget.orthoMatrix);
 240     mRenderState.stencil().enableTest(incrementThreshold);
 241 }
 242
 243 void BakedOpRenderer::setupStencilRectList(const ClipBase* clip) {
 244     LOG_ALWAYS_FATAL_IF(clip->mode != ClipMode::RectangleList, "can't rectlist clip without rectlist");
 245     auto&& rectList = reinterpret_cast<const ClipRectList*>(clip)->rectList;
 246     int quadCount = rectList.getTransformedRectanglesCount();
 247     std::vector<Vertex> rectangleVertices;
 248     rectangleVertices.reserve(quadCount * 4);
 249     for (int i = 0; i < quadCount; i++) {
 250         const TransformedRectangle& tr(rectList.getTransformedRectangle(i));
 251         const Matrix4& transform = tr.getTransform();
 252         Rect bounds = tr.getBounds();
 253         if (transform.rectToRect()) {
 254             // If rectToRect, can simply map bounds before storing verts
 255             transform.mapRect(bounds);
 256             bounds.doIntersect(clip->rect);
 257             if (bounds.isEmpty()) {
 258                 continue; // will be outside of scissor, skip
 259             }
 260         }
 261
 262         rectangleVertices.push_back(Vertex{bounds.left, bounds.top});
 263         rectangleVertices.push_back(Vertex{bounds.right, bounds.top});
 264         rectangleVertices.push_back(Vertex{bounds.left, bounds.bottom});
 265         rectangleVertices.push_back(Vertex{bounds.right, bounds.bottom});
 266
 267         if (!transform.rectToRect()) {
 268             // If not rectToRect, must map each point individually
 269             for (auto cur = rectangleVertices.end() - 4; cur < rectangleVertices.end(); cur++) {
 270                 transform.mapPoint(cur->x, cur->y);
 271             }
 272         }
 273     }
 274     setupStencilQuads(rectangleVertices, rectList.getTransformedRectanglesCount());
 275 }
 276
 277 void BakedOpRenderer::setupStencilRegion(const ClipBase* clip) {
 278     LOG_ALWAYS_FATAL_IF(clip->mode != ClipMode::Region, "can't region clip without region");
 279     auto&& region = reinterpret_cast<const ClipRegion*>(clip)->region;
 280
 281     std::vector<Vertex> regionVertices;
 282     SkRegion::Cliperator it(region, clip->rect.toSkIRect());
 283     while (!it.done()) {
 284         const SkIRect& r = it.rect();
 285         regionVertices.push_back(Vertex{(float)r.fLeft, (float)r.fTop});
 286         regionVertices.push_back(Vertex{(float)r.fRight, (float)r.fTop});
 287         regionVertices.push_back(Vertex{(float)r.fLeft, (float)r.fBottom});
 288         regionVertices.push_back(Vertex{(float)r.fRight, (float)r.fBottom});
 289         it.next();
 290     }
 291     setupStencilQuads(regionVertices, 0);
 292 }
 293
 294 void BakedOpRenderer::prepareRender(const Rect* dirtyBounds, const ClipBase* clip) {
 295     // Prepare scissor (done before stencil, to simplify filling stencil)
 296     mRenderState.scissor().setEnabled(clip != nullptr);
 297     if (clip) {
 298         mRenderState.scissor().set(mRenderTarget.viewportHeight, clip->rect);
 299     }
 300
 301     // If stencil may be used for clipping, enable it, fill it, or disable it as appropriate
 302     if (CC_LIKELY(!Properties::debugOverdraw)) {
 303         // only modify stencil mode and content when it's not used for overdraw visualization
 304         if (CC_UNLIKELY(clip && clip->mode != ClipMode::Rectangle)) {
 305             // NOTE: this pointer check is only safe for non-rect clips,
 306             // since rect clips may be created on the stack
 307             if (mRenderTarget.lastStencilClip != clip) {
 308                 // Stencil needed, but current stencil isn't up to date
 309                 mRenderTarget.lastStencilClip = clip;
 310
 311                 if (mRenderTarget.frameBufferId != 0 && !mRenderTarget.stencil) {
 312                     OffscreenBuffer* layer = mRenderTarget.offscreenBuffer;
 313                     mRenderTarget.stencil = mCaches.renderBufferCache.get(
 314                             Stencil::getLayerStencilFormat(),
 315                             layer->texture.width(), layer->texture.height());
 316                     // stencil is bound + allocated - associate it with current FBO
 317                     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
 318                             GL_RENDERBUFFER, mRenderTarget.stencil->getName());
 319                 }
 320
 321                 if (clip->mode == ClipMode::RectangleList) {
 322                     setupStencilRectList(clip);
 323                 } else {
 324                     setupStencilRegion(clip);
 325                 }
 326             } else {
 327                 // stencil is up to date - just need to ensure it's enabled (since an unclipped
 328                 // or scissor-only clipped op may have been drawn, disabling the stencil)
 329                 int incrementThreshold = 0;
 330                 if (CC_LIKELY(clip->mode == ClipMode::RectangleList)) {
 331                     auto&& rectList = reinterpret_cast<const ClipRectList*>(clip)->rectList;
 332                     incrementThreshold = rectList.getTransformedRectanglesCount();
 333                 }
 334                 mRenderState.stencil().enableTest(incrementThreshold);
 335             }
 336         } else {
 337             // either scissor or no clip, so disable stencil test
 338             mRenderState.stencil().disable();
 339         }
 340     }
 341
 342     if (dirtyBounds) {
 343         // dirty offscreenbuffer if present
 344         dirtyRenderTarget(*dirtyBounds);
 345     }
 346 }
 347
 348 void BakedOpRenderer::renderGlopImpl(const Rect* dirtyBounds, const ClipBase* clip,
 349         const Glop& glop) {
 350     prepareRender(dirtyBounds, clip);
 351     mRenderState.render(glop, mRenderTarget.orthoMatrix);
 352     if (!mRenderTarget.frameBufferId) mHasDrawn = true;
 353 }
 354
 355 void BakedOpRenderer::renderFunctor(const FunctorOp& op, const BakedOpState& state) {
 356     prepareRender(&state.computedState.clippedBounds, state.computedState.getClipIfNeeded());
 357
 358     DrawGlInfo info;
 359     auto&& clip = state.computedState.clipRect();
 360     info.clipLeft = clip.left;
 361     info.clipTop = clip.top;
 362     info.clipRight = clip.right;
 363     info.clipBottom = clip.bottom;
 364     info.isLayer = offscreenRenderTarget();
 365     info.width = mRenderTarget.viewportWidth;
 366     info.height = mRenderTarget.viewportHeight;
 367     state.computedState.transform.copyTo(&info.transform[0]);
 368
 369     mRenderState.invokeFunctor(op.functor, DrawGlInfo::kModeDraw, &info);
 370 }
 371
 372 void BakedOpRenderer::dirtyRenderTarget(const Rect& uiDirty) {
 373     if (mRenderTarget.offscreenBuffer) {
 374         mRenderTarget.offscreenBuffer->dirty(uiDirty);
 375     }
 376 }
 377
 378 } // namespace uirenderer
 379 } // namespace android