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 23 namespace android { 24 namespace uirenderer { 25 26 class Caches; 27 struct Glop; 28 class Layer; 29 class RenderState; 30 struct 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 */ 41 class BakedOpRenderer { 42 public: 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, bool wideColorGamut, 58 const LightInfo& lightInfo) 59 : mGlopReceiver(DefaultGlopReceiver) 60 , mRenderState(renderState) 61 , mCaches(caches) 62 , mOpaque(opaque) 63 , mWideColorGamut(wideColorGamut) 64 , mLightInfo(lightInfo) { 65 } 66 67 RenderState& renderState() { return mRenderState; } 68 Caches& caches() { return mCaches; } 69 70 void startFrame(uint32_t width, uint32_t height, const Rect& repaintRect); 71 void endFrame(const Rect& repaintRect); 72 WARN_UNUSED_RESULT OffscreenBuffer* startTemporaryLayer(uint32_t width, uint32_t height); 73 void recycleTemporaryLayer(OffscreenBuffer* offscreenBuffer); 74 void startRepaintLayer(OffscreenBuffer* offscreenBuffer, const Rect& repaintRect); 75 void endLayer(); 76 WARN_UNUSED_RESULT OffscreenBuffer* copyToLayer(const Rect& area); 77 78 Texture* getTexture(Bitmap* bitmap); 79 const LightInfo& getLightInfo() const { return mLightInfo; } 80 81 void renderGlop(const BakedOpState& state, const Glop& glop) { 82 renderGlop(&state.computedState.clippedBounds, 83 state.computedState.getClipIfNeeded(), 84 glop); 85 } 86 void renderFunctor(const FunctorOp& op, const BakedOpState& state); 87 88 void renderGlop(const Rect* dirtyBounds, const ClipBase* clip, const Glop& glop) { 89 mGlopReceiver(*this, dirtyBounds, clip, glop); 90 } 91 bool offscreenRenderTarget() { return mRenderTarget.offscreenBuffer != nullptr; } 92 void dirtyRenderTarget(const Rect& dirtyRect); 93 bool didDraw() const { return mHasDrawn; } 94 95 uint32_t getViewportWidth() const { return mRenderTarget.viewportWidth; } 96 uint32_t getViewportHeight() const { return mRenderTarget.viewportHeight; } 97 98 // simple draw methods, to be used for end frame decoration 99 void drawRect(float left, float top, float right, float bottom, const SkPaint* paint) { 100 float ltrb[4] = { left, top, right, bottom }; 101 drawRects(ltrb, 4, paint); 102 } 103 void drawRects(const float* rects, int count, const SkPaint* paint); 104 protected: 105 GlopReceiver mGlopReceiver; 106 private: 107 static void DefaultGlopReceiver(BakedOpRenderer& renderer, const Rect* dirtyBounds, 108 const ClipBase* clip, const Glop& glop) { 109 renderer.renderGlopImpl(dirtyBounds, clip, glop); 110 } 111 void renderGlopImpl(const Rect* dirtyBounds, const ClipBase* clip, const Glop& glop); 112 void setViewport(uint32_t width, uint32_t height); 113 void clearColorBuffer(const Rect& clearRect); 114 void prepareRender(const Rect* dirtyBounds, const ClipBase* clip); 115 void setupStencilRectList(const ClipBase* clip); 116 void setupStencilRegion(const ClipBase* clip); 117 void setupStencilQuads(std::vector<Vertex>& quadVertices, int incrementThreshold); 118 119 RenderState& mRenderState; 120 Caches& mCaches; 121 bool mOpaque; 122 bool mWideColorGamut; 123 bool mHasDrawn = false; 124 125 // render target state - setup by start/end layer/frame 126 // only valid to use in between start/end pairs. 127 struct { 128 // If not drawing to a layer: fbo = 0, offscreenBuffer = null, 129 // Otherwise these refer to currently painting layer's state 130 GLuint frameBufferId = 0; 131 OffscreenBuffer* offscreenBuffer = nullptr; 132 133 // Used when drawing to a layer and using stencil clipping. otherwise null. 134 RenderBuffer* stencil = nullptr; 135 136 // value representing the ClipRectList* or ClipRegion* currently stored in 137 // the stencil of the current render target 138 const ClipBase* lastStencilClip = nullptr; 139 140 // Size of renderable region in current render target - for layers, may not match actual 141 // bounds of FBO texture. offscreenBuffer->texture has this information. 142 uint32_t viewportWidth = 0; 143 uint32_t viewportHeight = 0; 144 145 Matrix4 orthoMatrix; 146 } mRenderTarget; 147 148 const LightInfo mLightInfo; 149 }; 150 151 }; // namespace uirenderer 152 }; // namespace android 153