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