Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 1 | /* |
Chris Craik | 5ea1724 | 2016-01-11 14:07:59 -0800 | [diff] [blame] | 2 | * Copyright (C) 2016 The Android Open Source Project |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 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 | |
Chris Craik | 5ea1724 | 2016-01-11 14:07:59 -0800 | [diff] [blame] | 17 | #pragma once |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 18 | |
| 19 | #include "BakedOpState.h" |
| 20 | #include "CanvasState.h" |
| 21 | #include "DisplayList.h" |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 22 | #include "LayerBuilder.h" |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 23 | #include "RecordedOp.h" |
John Reck | 9372ac3 | 2016-01-19 11:46:52 -0800 | [diff] [blame] | 24 | #include "utils/GLUtils.h" |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 25 | |
| 26 | #include <vector> |
| 27 | #include <unordered_map> |
| 28 | |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 29 | struct SkRect; |
| 30 | |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 31 | namespace android { |
| 32 | namespace uirenderer { |
| 33 | |
| 34 | class BakedOpState; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 35 | class LayerUpdateQueue; |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 36 | class OffscreenBuffer; |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 37 | class Rect; |
| 38 | |
Chris Craik | 5ea1724 | 2016-01-11 14:07:59 -0800 | [diff] [blame] | 39 | /** |
Chris Craik | 9cd1bbe | 2016-04-14 16:08:25 -0700 | [diff] [blame] | 40 | * Processes, optimizes, and stores rendering commands from RenderNodes and |
| 41 | * LayerUpdateQueue, building content needed to render a frame. |
Chris Craik | 5ea1724 | 2016-01-11 14:07:59 -0800 | [diff] [blame] | 42 | * |
| 43 | * Resolves final drawing state for each operation (including clip, alpha and matrix), and then |
| 44 | * reorder and merge each op as it is resolved for drawing efficiency. Each layer of content (either |
| 45 | * from the LayerUpdateQueue, or temporary layers created by saveLayer operations in the |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 46 | * draw stream) will create different reorder contexts, each in its own LayerBuilder. |
Chris Craik | 5ea1724 | 2016-01-11 14:07:59 -0800 | [diff] [blame] | 47 | * |
| 48 | * Then the prepared or 'baked' drawing commands can be issued by calling the templated |
| 49 | * replayBakedOps() function, which will dispatch them (including any created merged op collections) |
| 50 | * to a Dispatcher and Renderer. See BakedOpDispatcher for how these baked drawing operations are |
| 51 | * resolved into Glops and rendered via BakedOpRenderer. |
| 52 | * |
| 53 | * This class is also the authoritative source for traversing RenderNodes, both for standard op |
| 54 | * traversal within a DisplayList, and for out of order RenderNode traversal for Z and projection. |
| 55 | */ |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 56 | class FrameBuilder : public CanvasStateClient { |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 57 | public: |
Chris Craik | 6e068c01 | 2016-01-15 16:15:30 -0800 | [diff] [blame] | 58 | struct LightGeometry { |
| 59 | Vector3 center; |
| 60 | float radius; |
| 61 | }; |
| 62 | |
Chris Craik | 9cd1bbe | 2016-04-14 16:08:25 -0700 | [diff] [blame] | 63 | FrameBuilder(const SkRect& clip, |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 64 | uint32_t viewportWidth, uint32_t viewportHeight, |
Chris Craik | 9cd1bbe | 2016-04-14 16:08:25 -0700 | [diff] [blame] | 65 | const LightGeometry& lightGeometry, Caches& caches); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 66 | |
Chris Craik | 9cd1bbe | 2016-04-14 16:08:25 -0700 | [diff] [blame] | 67 | FrameBuilder(const LayerUpdateQueue& layerUpdateQueue, |
| 68 | const LightGeometry& lightGeometry, Caches& caches); |
| 69 | |
| 70 | void deferLayers(const LayerUpdateQueue& layers); |
| 71 | |
| 72 | void deferRenderNode(RenderNode& renderNode); |
| 73 | |
| 74 | void deferRenderNode(float tx, float ty, Rect clipRect, RenderNode& renderNode); |
| 75 | |
| 76 | void deferRenderNodeScene(const std::vector< sp<RenderNode> >& nodes, |
| 77 | const Rect& contentDrawBounds); |
Chong Zhang | c3bd568 | 2016-01-25 12:01:12 -0800 | [diff] [blame] | 78 | |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 79 | virtual ~FrameBuilder() {} |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 80 | |
| 81 | /** |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 82 | * replayBakedOps() is templated based on what class will receive ops being replayed. |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 83 | * |
| 84 | * It constructs a lookup array of lambdas, which allows a recorded BakeOpState to use |
| 85 | * state->op->opId to lookup a receiver that will be called when the op is replayed. |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 86 | */ |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 87 | template <typename StaticDispatcher, typename Renderer> |
| 88 | void replayBakedOps(Renderer& renderer) { |
Chris Craik | 74af6e2 | 2016-04-05 13:18:56 -0700 | [diff] [blame] | 89 | std::vector<OffscreenBuffer*> temporaryLayers; |
Chris Craik | 3a5811b | 2016-03-22 15:03:08 -0700 | [diff] [blame] | 90 | finishDefer(); |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 91 | /** |
Chris Craik | 7cbf63d | 2016-01-06 13:46:52 -0800 | [diff] [blame] | 92 | * Defines a LUT of lambdas which allow a recorded BakedOpState to use state->op->opId to |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 93 | * dispatch the op via a method on a static dispatcher when the op is replayed. |
| 94 | * |
| 95 | * For example a BitmapOp would resolve, via the lambda lookup, to calling: |
| 96 | * |
| 97 | * StaticDispatcher::onBitmapOp(Renderer& renderer, const BitmapOp& op, const BakedOpState& state); |
| 98 | */ |
| 99 | #define X(Type) \ |
| 100 | [](void* renderer, const BakedOpState& state) { \ |
Chris Craik | b87eadd | 2016-01-06 09:16:05 -0800 | [diff] [blame] | 101 | StaticDispatcher::on##Type(*(static_cast<Renderer*>(renderer)), \ |
| 102 | static_cast<const Type&>(*(state.op)), state); \ |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 103 | }, |
Chris Craik | 7cbf63d | 2016-01-06 13:46:52 -0800 | [diff] [blame] | 104 | static BakedOpReceiver unmergedReceivers[] = BUILD_RENDERABLE_OP_LUT(X); |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 105 | #undef X |
| 106 | |
| 107 | /** |
Chris Craik | 7cbf63d | 2016-01-06 13:46:52 -0800 | [diff] [blame] | 108 | * Defines a LUT of lambdas which allow merged arrays of BakedOpState* to be passed to a |
| 109 | * static dispatcher when the group of merged ops is replayed. |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 110 | */ |
| 111 | #define X(Type) \ |
| 112 | [](void* renderer, const MergedBakedOpList& opList) { \ |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 113 | StaticDispatcher::onMerged##Type##s(*(static_cast<Renderer*>(renderer)), opList); \ |
| 114 | }, |
Chris Craik | 7cbf63d | 2016-01-06 13:46:52 -0800 | [diff] [blame] | 115 | static MergedOpReceiver mergedReceivers[] = BUILD_MERGEABLE_OP_LUT(X); |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 116 | #undef X |
Chris Craik | 818c9fb | 2015-10-23 14:33:42 -0700 | [diff] [blame] | 117 | |
| 118 | // Relay through layers in reverse order, since layers |
| 119 | // later in the list will be drawn by earlier ones |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 120 | for (int i = mLayerBuilders.size() - 1; i >= 1; i--) { |
John Reck | 975591a | 2016-01-22 16:28:07 -0800 | [diff] [blame] | 121 | GL_CHECKPOINT(MODERATE); |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 122 | LayerBuilder& layer = *(mLayerBuilders[i]); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 123 | if (layer.renderNode) { |
| 124 | // cached HW layer - can't skip layer if empty |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 125 | renderer.startRepaintLayer(layer.offscreenBuffer, layer.repaintRect); |
John Reck | 975591a | 2016-01-22 16:28:07 -0800 | [diff] [blame] | 126 | GL_CHECKPOINT(MODERATE); |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 127 | layer.replayBakedOpsImpl((void*)&renderer, unmergedReceivers, mergedReceivers); |
John Reck | 975591a | 2016-01-22 16:28:07 -0800 | [diff] [blame] | 128 | GL_CHECKPOINT(MODERATE); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 129 | renderer.endLayer(); |
Chris Craik | c0f3f2f | 2016-02-02 16:10:32 -0800 | [diff] [blame] | 130 | } else if (!layer.empty()) { |
| 131 | // save layer - skip entire layer if empty (in which case, LayerOp has null layer). |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 132 | layer.offscreenBuffer = renderer.startTemporaryLayer(layer.width, layer.height); |
Chris Craik | 74af6e2 | 2016-04-05 13:18:56 -0700 | [diff] [blame] | 133 | temporaryLayers.push_back(layer.offscreenBuffer); |
John Reck | 975591a | 2016-01-22 16:28:07 -0800 | [diff] [blame] | 134 | GL_CHECKPOINT(MODERATE); |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 135 | layer.replayBakedOpsImpl((void*)&renderer, unmergedReceivers, mergedReceivers); |
John Reck | 975591a | 2016-01-22 16:28:07 -0800 | [diff] [blame] | 136 | GL_CHECKPOINT(MODERATE); |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 137 | renderer.endLayer(); |
Chris Craik | 818c9fb | 2015-10-23 14:33:42 -0700 | [diff] [blame] | 138 | } |
| 139 | } |
| 140 | |
John Reck | 975591a | 2016-01-22 16:28:07 -0800 | [diff] [blame] | 141 | GL_CHECKPOINT(MODERATE); |
Chris Craik | 6246d278 | 2016-03-29 15:01:41 -0700 | [diff] [blame] | 142 | if (CC_LIKELY(mDrawFbo0)) { |
| 143 | const LayerBuilder& fbo0 = *(mLayerBuilders[0]); |
| 144 | renderer.startFrame(fbo0.width, fbo0.height, fbo0.repaintRect); |
| 145 | GL_CHECKPOINT(MODERATE); |
| 146 | fbo0.replayBakedOpsImpl((void*)&renderer, unmergedReceivers, mergedReceivers); |
| 147 | GL_CHECKPOINT(MODERATE); |
| 148 | renderer.endFrame(fbo0.repaintRect); |
| 149 | } |
Chris Craik | 74af6e2 | 2016-04-05 13:18:56 -0700 | [diff] [blame] | 150 | |
| 151 | for (auto& temporaryLayer : temporaryLayers) { |
| 152 | renderer.recycleTemporaryLayer(temporaryLayer); |
| 153 | } |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 154 | } |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 155 | |
| 156 | void dump() const { |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 157 | for (auto&& layer : mLayerBuilders) { |
Chris Craik | 84ad614 | 2016-01-12 12:09:19 -0800 | [diff] [blame] | 158 | layer->dump(); |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 159 | } |
| 160 | } |
| 161 | |
| 162 | /////////////////////////////////////////////////////////////////// |
| 163 | /// CanvasStateClient interface |
| 164 | /////////////////////////////////////////////////////////////////// |
| 165 | virtual void onViewportInitialized() override; |
| 166 | virtual void onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) override; |
| 167 | virtual GLuint getTargetFbo() const override { return 0; } |
| 168 | |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 169 | private: |
Chris Craik | 3a5811b | 2016-03-22 15:03:08 -0700 | [diff] [blame] | 170 | void finishDefer(); |
Chris Craik | 161f54b | 2015-11-05 11:08:52 -0800 | [diff] [blame] | 171 | enum class ChildrenSelectMode { |
| 172 | Negative, |
| 173 | Positive |
| 174 | }; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 175 | void saveForLayer(uint32_t layerWidth, uint32_t layerHeight, |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 176 | float contentTranslateX, float contentTranslateY, |
| 177 | const Rect& repaintRect, |
| 178 | const Vector3& lightCenter, |
| 179 | const BeginLayerOp* beginLayerOp, RenderNode* renderNode); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 180 | void restoreForLayer(); |
| 181 | |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 182 | LayerBuilder& currentLayer() { return *(mLayerBuilders[mLayerStack.back()]); } |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 183 | |
| 184 | BakedOpState* tryBakeOpState(const RecordedOp& recordedOp) { |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 185 | return BakedOpState::tryConstruct(mAllocator, *mCanvasState.writableSnapshot(), recordedOp); |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 186 | } |
Chris Craik | 4c3980b | 2016-03-15 14:20:18 -0700 | [diff] [blame] | 187 | BakedOpState* tryBakeUnboundedOpState(const RecordedOp& recordedOp) { |
| 188 | return BakedOpState::tryConstructUnbounded(mAllocator, *mCanvasState.writableSnapshot(), recordedOp); |
| 189 | } |
| 190 | |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 191 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 192 | // should always be surrounded by a save/restore pair, and not called if DisplayList is null |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 193 | void deferNodePropsAndOps(RenderNode& node); |
| 194 | |
Chris Craik | 161f54b | 2015-11-05 11:08:52 -0800 | [diff] [blame] | 195 | template <typename V> |
Chris Craik | d645640 | 2016-04-11 12:24:23 -0700 | [diff] [blame] | 196 | void defer3dChildren(const ClipBase* reorderClip, ChildrenSelectMode mode, |
| 197 | const V& zTranslatedNodes); |
Chris Craik | 161f54b | 2015-11-05 11:08:52 -0800 | [diff] [blame] | 198 | |
Chris Craik | d645640 | 2016-04-11 12:24:23 -0700 | [diff] [blame] | 199 | void deferShadow(const ClipBase* reorderClip, const RenderNodeOp& casterOp); |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 200 | |
| 201 | void deferProjectedChildren(const RenderNode& renderNode); |
| 202 | |
| 203 | void deferNodeOps(const RenderNode& renderNode); |
| 204 | |
Chris Craik | 268a9c0 | 2015-12-09 18:05:12 -0800 | [diff] [blame] | 205 | void deferRenderNodeOpImpl(const RenderNodeOp& op); |
Chris Craik | 161f54b | 2015-11-05 11:08:52 -0800 | [diff] [blame] | 206 | |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 207 | void replayBakedOpsImpl(void* arg, BakedOpReceiver* receivers); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 208 | |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 209 | SkPath* createFrameAllocatedPath() { |
Chris Craik | b87eadd | 2016-01-06 09:16:05 -0800 | [diff] [blame] | 210 | return mAllocator.create<SkPath>(); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 211 | } |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 212 | |
Chris Craik | 80d2ade | 2016-03-28 12:54:07 -0700 | [diff] [blame] | 213 | BakedOpState* deferStrokeableOp(const RecordedOp& op, batchid_t batchId, |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 214 | BakedOpState::StrokeBehavior strokeBehavior = BakedOpState::StrokeBehavior::StyleDefined); |
| 215 | |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 216 | /** |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 217 | * Declares all FrameBuilder::deferXXXXOp() methods for every RecordedOp type. |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 218 | * |
| 219 | * These private methods are called from within deferImpl to defer each individual op |
| 220 | * type differently. |
| 221 | */ |
Chris Craik | 7cbf63d | 2016-01-06 13:46:52 -0800 | [diff] [blame] | 222 | #define X(Type) void defer##Type(const Type& op); |
| 223 | MAP_DEFERRABLE_OPS(X) |
| 224 | #undef X |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 225 | |
Chris Craik | 9cd1bbe | 2016-04-14 16:08:25 -0700 | [diff] [blame] | 226 | // contains single-frame objects, such as BakedOpStates, LayerBuilders, Batches |
| 227 | LinearAllocator mAllocator; |
| 228 | LinearStdAllocator<void*> mStdAllocator; |
| 229 | |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 230 | // List of every deferred layer's render state. Replayed in reverse order to render a frame. |
Chris Craik | 9cd1bbe | 2016-04-14 16:08:25 -0700 | [diff] [blame] | 231 | LsaVector<LayerBuilder*> mLayerBuilders; |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 232 | |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 233 | /* |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 234 | * Stack of indices within mLayerBuilders representing currently active layers. If drawing |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 235 | * layerA within a layerB, will contain, in order: |
| 236 | * - 0 (representing FBO 0, always present) |
| 237 | * - layerB's index |
| 238 | * - layerA's index |
| 239 | * |
Chris Craik | f158b49 | 2016-01-12 14:45:08 -0800 | [diff] [blame] | 240 | * Note that this doesn't vector doesn't always map onto all values of mLayerBuilders. When a |
| 241 | * layer is finished deferring, it will still be represented in mLayerBuilders, but it's index |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 242 | * won't be in mLayerStack. This is because it can be replayed, but can't have any more drawing |
| 243 | * ops added to it. |
| 244 | */ |
Chris Craik | 9cd1bbe | 2016-04-14 16:08:25 -0700 | [diff] [blame] | 245 | LsaVector<size_t> mLayerStack; |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 246 | |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 247 | CanvasState mCanvasState; |
| 248 | |
Chris Craik | 3a5811b | 2016-03-22 15:03:08 -0700 | [diff] [blame] | 249 | Caches& mCaches; |
Chris Craik | 6e068c01 | 2016-01-15 16:15:30 -0800 | [diff] [blame] | 250 | |
| 251 | float mLightRadius; |
| 252 | |
Chris Craik | 6246d278 | 2016-03-29 15:01:41 -0700 | [diff] [blame] | 253 | const bool mDrawFbo0; |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 254 | }; |
| 255 | |
| 256 | }; // namespace uirenderer |
| 257 | }; // namespace android |