John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2014 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 | |
Chris Craik | 5e00c7c | 2016-07-06 16:10:09 -0700 | [diff] [blame] | 17 | #pragma once |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 18 | |
Chris Craik | 5e00c7c | 2016-07-06 16:10:09 -0700 | [diff] [blame] | 19 | #include "BakedOpDispatcher.h" |
| 20 | #include "BakedOpRenderer.h" |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 21 | #include "DamageAccumulator.h" |
Chris Craik | 5e00c7c | 2016-07-06 16:10:09 -0700 | [diff] [blame] | 22 | #include "FrameBuilder.h" |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 23 | #include "FrameInfo.h" |
John Reck | 4c9e59d | 2015-05-12 07:17:50 -0700 | [diff] [blame] | 24 | #include "FrameInfoVisualizer.h" |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 25 | #include "FrameMetricsReporter.h" |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 26 | #include "IContextFactory.h" |
Stan Iliev | 768e393 | 2016-07-08 21:34:52 -0400 | [diff] [blame] | 27 | #include "IRenderPipeline.h" |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 28 | #include "LayerUpdateQueue.h" |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 29 | #include "RenderNode.h" |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 30 | #include "renderthread/RenderTask.h" |
| 31 | #include "renderthread/RenderThread.h" |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 32 | #include "thread/Task.h" |
| 33 | #include "thread/TaskProcessor.h" |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 34 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 35 | #include <EGL/egl.h> |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 36 | #include <SkBitmap.h> |
John Reck | d04794a | 2015-05-08 10:04:36 -0700 | [diff] [blame] | 37 | #include <SkRect.h> |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 38 | #include <cutils/compiler.h> |
John Reck | f648108 | 2016-02-02 15:18:23 -0800 | [diff] [blame] | 39 | #include <gui/Surface.h> |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 40 | #include <utils/Functor.h> |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 41 | |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 42 | #include <functional> |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 43 | #include <set> |
John Reck | b36016c | 2015-03-11 08:50:53 -0700 | [diff] [blame] | 44 | #include <string> |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 45 | #include <vector> |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 46 | |
| 47 | namespace android { |
| 48 | namespace uirenderer { |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 49 | |
John Reck | 119907c | 2014-08-14 09:02:01 -0700 | [diff] [blame] | 50 | class AnimationContext; |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 51 | class DeferredLayerUpdater; |
Stan Iliev | 216b157 | 2018-03-26 14:29:50 -0400 | [diff] [blame] | 52 | class ErrorHandler; |
John Reck | 1949e79 | 2014-04-08 15:18:56 -0700 | [diff] [blame] | 53 | class Layer; |
Chris Craik | 5e00c7c | 2016-07-06 16:10:09 -0700 | [diff] [blame] | 54 | class Rect; |
John Reck | 443a714 | 2014-09-04 17:40:05 -0700 | [diff] [blame] | 55 | class RenderState; |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 56 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 57 | namespace renderthread { |
| 58 | |
John Reck | 3b20251 | 2014-06-23 13:13:08 -0700 | [diff] [blame] | 59 | class EglManager; |
Stan Iliev | 768e393 | 2016-07-08 21:34:52 -0400 | [diff] [blame] | 60 | class Frame; |
John Reck | 1125d1f | 2014-10-23 11:02:19 -0700 | [diff] [blame] | 61 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 62 | // This per-renderer class manages the bridge between the global EGL context |
| 63 | // and the render surface. |
John Reck | 119907c | 2014-08-14 09:02:01 -0700 | [diff] [blame] | 64 | // TODO: Rename to Renderer or some other per-window, top-level manager |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 65 | class CanvasContext : public IFrameCallback { |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 66 | public: |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 67 | static CanvasContext* create(RenderThread& thread, bool translucent, RenderNode* rootRenderNode, |
| 68 | IContextFactory* contextFactory); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 69 | virtual ~CanvasContext(); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 70 | |
Derek Sollenberger | 6a21ca5 | 2016-09-28 13:39:55 -0400 | [diff] [blame] | 71 | /** |
| 72 | * Update or create a layer specific for the provided RenderNode. The layer |
| 73 | * attached to the node will be specific to the RenderPipeline used by this |
| 74 | * context |
| 75 | * |
| 76 | * @return true if the layer has been created or updated |
| 77 | */ |
Stan Iliev | 216b157 | 2018-03-26 14:29:50 -0400 | [diff] [blame] | 78 | bool createOrUpdateLayer(RenderNode* node, const DamageAccumulator& dmgAccumulator, |
| 79 | ErrorHandler* errorHandler) { |
| 80 | return mRenderPipeline->createOrUpdateLayer(node, dmgAccumulator, mWideColorGamut, |
John Reck | ec10097 | 2018-04-05 16:41:41 -0700 | [diff] [blame] | 81 | errorHandler); |
Derek Sollenberger | 6a21ca5 | 2016-09-28 13:39:55 -0400 | [diff] [blame] | 82 | } |
| 83 | |
| 84 | /** |
Derek Sollenberger | b7d34b6 | 2016-11-04 10:46:18 -0400 | [diff] [blame] | 85 | * Pin any mutable images to the GPU cache. A pinned images is guaranteed to |
| 86 | * remain in the cache until it has been unpinned. We leverage this feature |
| 87 | * to avoid making a CPU copy of the pixels. |
| 88 | * |
Derek Sollenberger | 189e874 | 2016-11-16 16:00:17 -0500 | [diff] [blame] | 89 | * @return true if all images have been successfully pinned to the GPU cache |
Derek Sollenberger | b7d34b6 | 2016-11-04 10:46:18 -0400 | [diff] [blame] | 90 | * and false otherwise (e.g. cache limits have been exceeded). |
| 91 | */ |
| 92 | bool pinImages(std::vector<SkImage*>& mutableImages) { |
| 93 | return mRenderPipeline->pinImages(mutableImages); |
| 94 | } |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 95 | bool pinImages(LsaVector<sk_sp<Bitmap>>& images) { return mRenderPipeline->pinImages(images); } |
Derek Sollenberger | b7d34b6 | 2016-11-04 10:46:18 -0400 | [diff] [blame] | 96 | |
| 97 | /** |
| 98 | * Unpin any image that had be previously pinned to the GPU cache |
| 99 | */ |
| 100 | void unpinImages() { mRenderPipeline->unpinImages(); } |
| 101 | |
| 102 | /** |
Derek Sollenberger | 6a21ca5 | 2016-09-28 13:39:55 -0400 | [diff] [blame] | 103 | * Destroy any layers that have been attached to the provided RenderNode removing |
| 104 | * any state that may have been set during createOrUpdateLayer(). |
| 105 | */ |
| 106 | static void destroyLayer(RenderNode* node); |
| 107 | |
Derek Sollenberger | daf7229 | 2016-10-25 12:09:18 -0400 | [diff] [blame] | 108 | static void invokeFunctor(const RenderThread& thread, Functor* functor); |
| 109 | |
| 110 | static void prepareToDraw(const RenderThread& thread, Bitmap* bitmap); |
| 111 | |
Derek Sollenberger | 0df6209 | 2016-09-27 16:04:42 -0400 | [diff] [blame] | 112 | /* |
| 113 | * If Properties::isSkiaEnabled() is true then this will return the Skia |
| 114 | * grContext associated with the current RenderPipeline. |
| 115 | */ |
Derek Sollenberger | 98f75d5 | 2016-10-25 10:25:45 -0400 | [diff] [blame] | 116 | GrContext* getGrContext() const { return mRenderThread.getGrContext(); } |
Derek Sollenberger | 0df6209 | 2016-09-27 16:04:42 -0400 | [diff] [blame] | 117 | |
John Reck | 1125d1f | 2014-10-23 11:02:19 -0700 | [diff] [blame] | 118 | // Won't take effect until next EGLSurface creation |
| 119 | void setSwapBehavior(SwapBehavior swapBehavior); |
| 120 | |
John Reck | f8441e6 | 2017-10-23 13:10:41 -0700 | [diff] [blame] | 121 | void setSurface(sp<Surface>&& surface); |
| 122 | bool pauseSurface(); |
John Reck | 8afcc76 | 2016-04-13 10:24:06 -0700 | [diff] [blame] | 123 | void setStopped(bool stopped); |
John Reck | f648108 | 2016-02-02 15:18:23 -0800 | [diff] [blame] | 124 | bool hasSurface() { return mNativeSurface.get(); } |
John Reck | aa95a88 | 2014-11-07 11:02:07 -0800 | [diff] [blame] | 125 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 126 | void setup(float lightRadius, uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha); |
Alan Viverette | 50210d9 | 2015-05-14 18:05:36 -0700 | [diff] [blame] | 127 | void setLightCenter(const Vector3& lightCenter); |
John Reck | 63a0667 | 2014-05-07 13:45:54 -0700 | [diff] [blame] | 128 | void setOpaque(bool opaque); |
Romain Guy | 26a2b97 | 2017-04-17 09:39:51 -0700 | [diff] [blame] | 129 | void setWideGamut(bool wideGamut); |
John Reck | 8afcc76 | 2016-04-13 10:24:06 -0700 | [diff] [blame] | 130 | bool makeCurrent(); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 131 | void prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t syncQueued, RenderNode* target); |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 132 | void draw(); |
John Reck | 2de950d | 2017-01-25 10:58:30 -0800 | [diff] [blame] | 133 | void destroy(); |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 134 | |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 135 | // IFrameCallback, Choreographer-driven frame callback entry point |
Chris Craik | d41c4d8 | 2015-01-05 15:51:13 -0800 | [diff] [blame] | 136 | virtual void doFrame() override; |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 137 | void prepareAndDraw(RenderNode* node); |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 138 | |
John Reck | 2de950d | 2017-01-25 10:58:30 -0800 | [diff] [blame] | 139 | void buildLayer(RenderNode* node); |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 140 | bool copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap); |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 141 | void markLayerInUse(RenderNode* node); |
John Reck | 19b6bcf | 2014-02-14 20:03:38 -0800 | [diff] [blame] | 142 | |
John Reck | 2de950d | 2017-01-25 10:58:30 -0800 | [diff] [blame] | 143 | void destroyHardwareResources(); |
John Reck | f47a594 | 2014-06-30 16:20:04 -0700 | [diff] [blame] | 144 | static void trimMemory(RenderThread& thread, int level); |
John Reck | e1628b7 | 2014-05-23 15:11:19 -0700 | [diff] [blame] | 145 | |
Derek Sollenberger | 56ad6ec | 2016-07-22 12:13:32 -0400 | [diff] [blame] | 146 | DeferredLayerUpdater* createTextureLayer(); |
John Reck | 1949e79 | 2014-04-08 15:18:56 -0700 | [diff] [blame] | 147 | |
John Reck | f47a594 | 2014-06-30 16:20:04 -0700 | [diff] [blame] | 148 | void stopDrawing(); |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 149 | void notifyFramePending(); |
| 150 | |
John Reck | 4c9e59d | 2015-05-12 07:17:50 -0700 | [diff] [blame] | 151 | FrameInfoVisualizer& profiler() { return mProfiler; } |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 152 | |
John Reck | ba6adf6 | 2015-02-19 14:36:50 -0800 | [diff] [blame] | 153 | void dumpFrames(int fd); |
| 154 | void resetFrameStats(); |
| 155 | |
John Reck | df1742e | 2017-01-19 15:56:21 -0800 | [diff] [blame] | 156 | void setName(const std::string&& name); |
John Reck | b36016c | 2015-03-11 08:50:53 -0700 | [diff] [blame] | 157 | |
John Reck | 2de950d | 2017-01-25 10:58:30 -0800 | [diff] [blame] | 158 | void addRenderNode(RenderNode* node, bool placeFront); |
| 159 | void removeRenderNode(RenderNode* node); |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 160 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 161 | void setContentDrawBounds(const Rect& bounds) { mContentDrawBounds = bounds; } |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 162 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 163 | RenderState& getRenderState() { return mRenderThread.renderState(); } |
Chris Craik | e2e53a7 | 2015-10-28 15:55:40 -0700 | [diff] [blame] | 164 | |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 165 | void addFrameMetricsObserver(FrameMetricsObserver* observer) { |
| 166 | if (mFrameMetricsReporter.get() == nullptr) { |
| 167 | mFrameMetricsReporter.reset(new FrameMetricsReporter()); |
Andres Morales | 06f5bc7 | 2015-12-15 15:21:31 -0800 | [diff] [blame] | 168 | } |
| 169 | |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 170 | mFrameMetricsReporter->addObserver(observer); |
Andres Morales | 06f5bc7 | 2015-12-15 15:21:31 -0800 | [diff] [blame] | 171 | } |
| 172 | |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 173 | void removeFrameMetricsObserver(FrameMetricsObserver* observer) { |
| 174 | if (mFrameMetricsReporter.get() != nullptr) { |
| 175 | mFrameMetricsReporter->removeObserver(observer); |
| 176 | if (!mFrameMetricsReporter->hasObservers()) { |
| 177 | mFrameMetricsReporter.reset(nullptr); |
Andres Morales | 06f5bc7 | 2015-12-15 15:21:31 -0800 | [diff] [blame] | 178 | } |
| 179 | } |
| 180 | } |
| 181 | |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 182 | // Used to queue up work that needs to be completed before this frame completes |
| 183 | ANDROID_API void enqueueFrameWork(std::function<void()>&& func); |
| 184 | |
John Reck | 28912a5 | 2016-04-18 14:34:18 -0700 | [diff] [blame] | 185 | ANDROID_API int64_t getFrameNumber(); |
| 186 | |
Chris Craik | 06e2e9c | 2016-08-31 17:32:46 -0700 | [diff] [blame] | 187 | void waitOnFences(); |
| 188 | |
Stan Iliev | 23c38a9 | 2017-03-23 00:12:50 -0400 | [diff] [blame] | 189 | IRenderPipeline* getRenderPipeline() { return mRenderPipeline.get(); } |
| 190 | |
John Reck | ec10097 | 2018-04-05 16:41:41 -0700 | [diff] [blame] | 191 | void setRenderAheadDepth(int renderAhead); |
| 192 | |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 193 | private: |
Stan Iliev | 03de074 | 2016-07-07 12:35:54 -0400 | [diff] [blame] | 194 | CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode, |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 195 | IContextFactory* contextFactory, std::unique_ptr<IRenderPipeline> renderPipeline); |
Stan Iliev | 03de074 | 2016-07-07 12:35:54 -0400 | [diff] [blame] | 196 | |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 197 | friend class RegisterFrameCallbackTask; |
John Reck | 443a714 | 2014-09-04 17:40:05 -0700 | [diff] [blame] | 198 | // TODO: Replace with something better for layer & other GL object |
| 199 | // lifecycle tracking |
| 200 | friend class android::uirenderer::RenderState; |
John Reck | a5dda64 | 2014-05-22 15:43:54 -0700 | [diff] [blame] | 201 | |
John Reck | 2de950d | 2017-01-25 10:58:30 -0800 | [diff] [blame] | 202 | void freePrefetchedLayers(); |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 203 | |
John Reck | 0def73a | 2016-07-01 16:19:13 -0700 | [diff] [blame] | 204 | bool isSwapChainStuffed(); |
John Reck | ec10097 | 2018-04-05 16:41:41 -0700 | [diff] [blame] | 205 | void updateBufferCount(); |
John Reck | 0def73a | 2016-07-01 16:19:13 -0700 | [diff] [blame] | 206 | |
Stan Iliev | 768e393 | 2016-07-08 21:34:52 -0400 | [diff] [blame] | 207 | SkRect computeDirtyRect(const Frame& frame, SkRect* dirty); |
| 208 | |
John Reck | 77c4010 | 2015-10-26 15:49:47 -0700 | [diff] [blame] | 209 | EGLint mLastFrameWidth = 0; |
| 210 | EGLint mLastFrameHeight = 0; |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 211 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 212 | RenderThread& mRenderThread; |
John Reck | f648108 | 2016-02-02 15:18:23 -0800 | [diff] [blame] | 213 | sp<Surface> mNativeSurface; |
John Reck | 306f331 | 2016-06-10 16:01:55 -0700 | [diff] [blame] | 214 | // stopped indicates the CanvasContext will reject actual redraw operations, |
| 215 | // and defer repaint until it is un-stopped |
John Reck | 8afcc76 | 2016-04-13 10:24:06 -0700 | [diff] [blame] | 216 | bool mStopped = false; |
John Reck | 306f331 | 2016-06-10 16:01:55 -0700 | [diff] [blame] | 217 | // CanvasContext is dirty if it has received an update that it has not |
| 218 | // painted onto its surface. |
| 219 | bool mIsDirty = false; |
Stan Iliev | 768e393 | 2016-07-08 21:34:52 -0400 | [diff] [blame] | 220 | SwapBehavior mSwapBehavior = SwapBehavior::kSwap_default; |
John Reck | e486d93 | 2015-10-28 09:21:19 -0700 | [diff] [blame] | 221 | struct SwapHistory { |
| 222 | SkRect damage; |
| 223 | nsecs_t vsyncTime; |
John Reck | 0def73a | 2016-07-01 16:19:13 -0700 | [diff] [blame] | 224 | nsecs_t swapCompletedTime; |
| 225 | nsecs_t dequeueDuration; |
| 226 | nsecs_t queueDuration; |
John Reck | e486d93 | 2015-10-28 09:21:19 -0700 | [diff] [blame] | 227 | }; |
| 228 | |
| 229 | RingBuffer<SwapHistory, 3> mSwapHistory; |
John Reck | 28912a5 | 2016-04-18 14:34:18 -0700 | [diff] [blame] | 230 | int64_t mFrameNumber = -1; |
John Reck | ec10097 | 2018-04-05 16:41:41 -0700 | [diff] [blame] | 231 | int mRenderAheadDepth = 0; |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 232 | |
Chris Craik | 3163568 | 2016-07-19 17:59:12 -0700 | [diff] [blame] | 233 | // last vsync for a dropped frame due to stuffed queue |
| 234 | nsecs_t mLastDropVsync = 0; |
| 235 | |
John Reck | 4f02bf4 | 2014-01-03 18:09:17 -0800 | [diff] [blame] | 236 | bool mOpaque; |
Romain Guy | 26a2b97 | 2017-04-17 09:39:51 -0700 | [diff] [blame] | 237 | bool mWideColorGamut = false; |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 238 | BakedOpRenderer::LightInfo mLightInfo; |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 239 | FrameBuilder::LightGeometry mLightGeometry = {{0, 0, 0}, 0}; |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 240 | |
John Reck | edc524c | 2015-03-18 15:24:33 -0700 | [diff] [blame] | 241 | bool mHaveNewSurface = false; |
John Reck | e4267ea | 2014-06-03 15:53:15 -0700 | [diff] [blame] | 242 | DamageAccumulator mDamageAccumulator; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 243 | LayerUpdateQueue mLayerUpdateQueue; |
Chris Craik | 51d6a3d | 2014-12-22 17:16:56 -0800 | [diff] [blame] | 244 | std::unique_ptr<AnimationContext> mAnimationContext; |
John Reck | e45b1fd | 2014-04-15 09:50:16 -0700 | [diff] [blame] | 245 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 246 | std::vector<sp<RenderNode>> mRenderNodes; |
John Reck | fe5e7b7 | 2014-05-23 17:42:28 -0700 | [diff] [blame] | 247 | |
John Reck | edc524c | 2015-03-18 15:24:33 -0700 | [diff] [blame] | 248 | FrameInfo* mCurrentFrameInfo = nullptr; |
John Reck | b36016c | 2015-03-11 08:50:53 -0700 | [diff] [blame] | 249 | std::string mName; |
John Reck | edc524c | 2015-03-18 15:24:33 -0700 | [diff] [blame] | 250 | JankTracker mJankTracker; |
John Reck | 4c9e59d | 2015-05-12 07:17:50 -0700 | [diff] [blame] | 251 | FrameInfoVisualizer mProfiler; |
Andres Morales | 910beb8 | 2016-02-02 16:19:40 -0800 | [diff] [blame] | 252 | std::unique_ptr<FrameMetricsReporter> mFrameMetricsReporter; |
John Reck | 998a6d8 | 2014-08-28 15:35:53 -0700 | [diff] [blame] | 253 | |
John Reck | 51f2d60 | 2016-04-06 07:50:47 -0700 | [diff] [blame] | 254 | std::set<RenderNode*> mPrefetchedLayers; |
Skuhne | ea7a7fb | 2015-08-28 07:10:31 -0700 | [diff] [blame] | 255 | |
| 256 | // Stores the bounds of the main content. |
Skuhne | b816087 | 2015-09-22 09:51:39 -0700 | [diff] [blame] | 257 | Rect mContentDrawBounds; |
John Reck | 38f6c03 | 2016-03-17 10:23:49 -0700 | [diff] [blame] | 258 | |
| 259 | // TODO: This is really a Task<void> but that doesn't really work |
| 260 | // when Future<> expects to be able to get/set a value |
| 261 | struct FuncTask : public Task<bool> { |
| 262 | std::function<void()> func; |
| 263 | }; |
| 264 | class FuncTaskProcessor; |
| 265 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 266 | std::vector<sp<FuncTask>> mFrameFences; |
| 267 | sp<TaskProcessor<bool>> mFrameWorkProcessor; |
Stan Iliev | 768e393 | 2016-07-08 21:34:52 -0400 | [diff] [blame] | 268 | std::unique_ptr<IRenderPipeline> mRenderPipeline; |
John Reck | 23b797a | 2014-01-03 18:08:34 -0800 | [diff] [blame] | 269 | }; |
| 270 | |
| 271 | } /* namespace renderthread */ |
| 272 | } /* namespace uirenderer */ |
| 273 | } /* namespace android */ |