BakedOpRenderer.h revision 419a1e7ef53468e494d21c66ea7f63c0c522d208
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#pragma once 18 19#include "BakedOpState.h" 20#include "Matrix.h" 21#include "utils/Macros.h" 22 23namespace android { 24namespace uirenderer { 25 26class Caches; 27struct Glop; 28class Layer; 29class RenderState; 30struct ClipBase; 31 32/** 33 * Main rendering manager for a collection of work - one frame + any contained FBOs. 34 * 35 * Manages frame and FBO lifecycle, binding the GL framebuffer as appropriate. This is the only 36 * place where FBOs are bound, created, and destroyed. 37 * 38 * All rendering operations will be sent by the Dispatcher, a collection of static methods, 39 * which has intentionally limited access to the renderer functionality. 40 */ 41class BakedOpRenderer { 42public: 43 typedef void (*GlopReceiver)(BakedOpRenderer&, const Rect*, const ClipBase*, const Glop&); 44 /** 45 * Position agnostic shadow lighting info. Used with all shadow ops in scene. 46 */ 47 struct LightInfo { 48 LightInfo() : LightInfo(0, 0) {} 49 LightInfo(uint8_t ambientShadowAlpha, 50 uint8_t spotShadowAlpha) 51 : ambientShadowAlpha(ambientShadowAlpha) 52 , spotShadowAlpha(spotShadowAlpha) {} 53 uint8_t ambientShadowAlpha; 54 uint8_t spotShadowAlpha; 55 }; 56 57 BakedOpRenderer(Caches& caches, RenderState& renderState, bool opaque, 58 const LightInfo& lightInfo) 59 : mGlopReceiver(DefaultGlopReceiver) 60 , mRenderState(renderState) 61 , mCaches(caches) 62 , mOpaque(opaque) 63 , mLightInfo(lightInfo) { 64 } 65 66 RenderState& renderState() { return mRenderState; } 67 Caches& caches() { return mCaches; } 68 69 void startFrame(uint32_t width, uint32_t height, const Rect& repaintRect); 70 void endFrame(const Rect& repaintRect); 71 WARN_UNUSED_RESULT OffscreenBuffer* startTemporaryLayer(uint32_t width, uint32_t height); 72 void startRepaintLayer(OffscreenBuffer* offscreenBuffer, const Rect& repaintRect); 73 void endLayer(); 74 WARN_UNUSED_RESULT OffscreenBuffer* copyToLayer(const Rect& area); 75 76 Texture* getTexture(const SkBitmap* bitmap); 77 const LightInfo& getLightInfo() const { return mLightInfo; } 78 79 void renderGlop(const BakedOpState& state, const Glop& glop) { 80 renderGlop(&state.computedState.clippedBounds, 81 state.computedState.getClipIfNeeded(), 82 glop); 83 } 84 void renderFunctor(const FunctorOp& op, const BakedOpState& state); 85 86 void renderGlop(const Rect* dirtyBounds, const ClipBase* clip, const Glop& glop) { 87 mGlopReceiver(*this, dirtyBounds, clip, glop); 88 } 89 bool offscreenRenderTarget() { return mRenderTarget.offscreenBuffer != nullptr; } 90 void dirtyRenderTarget(const Rect& dirtyRect); 91 bool didDraw() const { return mHasDrawn; } 92 93 uint32_t getViewportWidth() const { return mRenderTarget.viewportWidth; } 94 uint32_t getViewportHeight() const { return mRenderTarget.viewportHeight; } 95 96 // simple draw methods, to be used for end frame decoration 97 void drawRect(float left, float top, float right, float bottom, const SkPaint* paint) { 98 float ltrb[4] = { left, top, right, bottom }; 99 drawRects(ltrb, 4, paint); 100 } 101 void drawRects(const float* rects, int count, const SkPaint* paint); 102protected: 103 GlopReceiver mGlopReceiver; 104private: 105 static void DefaultGlopReceiver(BakedOpRenderer& renderer, const Rect* dirtyBounds, 106 const ClipBase* clip, const Glop& glop) { 107 renderer.renderGlopImpl(dirtyBounds, clip, glop); 108 } 109 void renderGlopImpl(const Rect* dirtyBounds, const ClipBase* clip, const Glop& glop); 110 void setViewport(uint32_t width, uint32_t height); 111 void clearColorBuffer(const Rect& clearRect); 112 void prepareRender(const Rect* dirtyBounds, const ClipBase* clip); 113 void setupStencilRectList(const ClipBase* clip); 114 void setupStencilRegion(const ClipBase* clip); 115 void setupStencilQuads(std::vector<Vertex>& quadVertices, int incrementThreshold); 116 117 RenderState& mRenderState; 118 Caches& mCaches; 119 bool mOpaque; 120 bool mHasDrawn = false; 121 122 // render target state - setup by start/end layer/frame 123 // only valid to use in between start/end pairs. 124 struct { 125 // If not drawing to a layer: fbo = 0, offscreenBuffer = null, 126 // Otherwise these refer to currently painting layer's state 127 GLuint frameBufferId = 0; 128 OffscreenBuffer* offscreenBuffer = nullptr; 129 130 // Used when drawing to a layer and using stencil clipping. otherwise null. 131 RenderBuffer* stencil = nullptr; 132 133 // value representing the ClipRectList* or ClipRegion* currently stored in 134 // the stencil of the current render target 135 const ClipBase* lastStencilClip = nullptr; 136 137 // Size of renderable region in current render target - for layers, may not match actual 138 // bounds of FBO texture. offscreenBuffer->texture has this information. 139 uint32_t viewportWidth = 0; 140 uint32_t viewportHeight = 0; 141 142 Matrix4 orthoMatrix; 143 } mRenderTarget; 144 145 const LightInfo mLightInfo; 146}; 147 148}; // namespace uirenderer 149}; // namespace android 150