libs/hwui/Caches.h

   1 /*
   2  * Copyright (C) 2010 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 #ifndef ANDROID_HWUI_CACHES_H
  18 #define ANDROID_HWUI_CACHES_H
  19
  20 #include "AssetAtlas.h"
  21 #include "Dither.h"
  22 #include "Extensions.h"
  23 #include "FboCache.h"
  24 #include "GammaFontRenderer.h"
  25 #include "GradientCache.h"
  26 #include "LayerCache.h"
  27 #include "PatchCache.h"
  28 #include "ProgramCache.h"
  29 #include "PathCache.h"
  30 #include "RenderBufferCache.h"
  31 #include "renderstate/PixelBufferState.h"
  32 #include "renderstate/TextureState.h"
  33 #include "ResourceCache.h"
  34 #include "TessellationCache.h"
  35 #include "TextDropShadowCache.h"
  36 #include "TextureCache.h"
  37 #include "thread/TaskProcessor.h"
  38 #include "thread/TaskManager.h"
  39
  40 #include <vector>
  41 #include <memory>
  42
  43 #include <GLES3/gl3.h>
  44
  45 #include <utils/KeyedVector.h>
  46
  47 #include <cutils/compiler.h>
  48
  49 #include <SkPath.h>
  50
  51 #include <vector>
  52
  53 namespace android {
  54 namespace uirenderer {
  55
  56 ///////////////////////////////////////////////////////////////////////////////
  57 // Caches
  58 ///////////////////////////////////////////////////////////////////////////////
  59
  60 class RenderNode;
  61 class RenderState;
  62
  63 class ANDROID_API Caches {
  64 public:
  65     static Caches& createInstance(RenderState& renderState) {
  66         LOG_ALWAYS_FATAL_IF(sInstance, "double create of Caches attempted");
  67         sInstance = new Caches(renderState);
  68         return *sInstance;
  69     }
  70
  71     static Caches& getInstance() {
  72         LOG_ALWAYS_FATAL_IF(!sInstance, "instance not yet created");
  73         return *sInstance;
  74     }
  75
  76     static bool hasInstance() {
  77         return sInstance != nullptr;
  78     }
  79 private:
  80     Caches(RenderState& renderState);
  81     static Caches* sInstance;
  82
  83 public:
  84     enum class FlushMode {
  85         Layers = 0,
  86         Moderate,
  87         Full
  88     };
  89
  90     /**
  91      * Initialize caches.
  92      */
  93     bool init();
  94
  95     bool isInitialized() { return mInitialized; }
  96
  97     /**
  98      * Flush the cache.
  99      *
 100      * @param mode Indicates how much of the cache should be flushed
 101      */
 102     void flush(FlushMode mode);
 103
 104     /**
 105      * Destroys all resources associated with this cache. This should
 106      * be called after a flush(FlushMode::Full).
 107      */
 108     void terminate();
 109
 110     /**
 111      * Returns a non-premultiplied ARGB color for the specified
 112      * amount of overdraw (1 for 1x, 2 for 2x, etc.)
 113      */
 114     uint32_t getOverdrawColor(uint32_t amount) const;
 115
 116     /**
 117      * Call this on each frame to ensure that garbage is deleted from
 118      * GPU memory.
 119      */
 120     void clearGarbage();
 121
 122     /**
 123      * Can be used to delete a layer from a non EGL thread.
 124      */
 125     void deleteLayerDeferred(Layer* layer);
 126
 127     /**
 128      * Returns the mesh used to draw regions. Calling this method will
 129      * bind a VBO of type GL_ELEMENT_ARRAY_BUFFER that contains the
 130      * indices for the region mesh.
 131      */
 132     TextureVertex* getRegionMesh();
 133
 134     /**
 135      * Displays the memory usage of each cache and the total sum.
 136      */
 137     void dumpMemoryUsage();
 138     void dumpMemoryUsage(String8& log);
 139
 140     // Misc
 141     GLint maxTextureSize;
 142
 143 private:
 144     // Declared before gradientCache and programCache which need this to initialize.
 145     // TODO: cleanup / move elsewhere
 146     Extensions mExtensions;
 147 public:
 148     TextureCache textureCache;
 149     LayerCache layerCache;
 150     RenderBufferCache renderBufferCache;
 151     GradientCache gradientCache;
 152     PatchCache patchCache;
 153     PathCache pathCache;
 154     ProgramCache programCache;
 155     TessellationCache tessellationCache;
 156     TextDropShadowCache dropShadowCache;
 157     FboCache fboCache;
 158
 159     GammaFontRenderer fontRenderer;
 160
 161     TaskManager tasks;
 162
 163     Dither dither;
 164
 165     bool gpuPixelBuffersEnabled;
 166
 167     // Debug methods
 168     PFNGLINSERTEVENTMARKEREXTPROC eventMark;
 169     PFNGLPUSHGROUPMARKEREXTPROC startMark;
 170     PFNGLPOPGROUPMARKEREXTPROC endMark;
 171
 172     void setProgram(const ProgramDescription& description);
 173     void setProgram(Program* program);
 174
 175     Extensions& extensions() { return mExtensions; }
 176     Program& program() { return *mProgram; }
 177     PixelBufferState& pixelBufferState() { return *mPixelBufferState; }
 178     TextureState& textureState() { return *mTextureState; }
 179
 180 private:
 181     void initExtensions();
 182     void initConstraints();
 183     void initStaticProperties();
 184
 185     static void eventMarkNull(GLsizei length, const GLchar* marker) { }
 186     static void startMarkNull(GLsizei length, const GLchar* marker) { }
 187     static void endMarkNull() { }
 188
 189     RenderState* mRenderState;
 190
 191     // Used to render layers
 192     std::unique_ptr<TextureVertex[]> mRegionMesh;
 193
 194     mutable Mutex mGarbageLock;
 195     std::vector<Layer*> mLayerGarbage;
 196
 197     bool mInitialized;
 198
 199     // TODO: move below to RenderState
 200     PixelBufferState* mPixelBufferState = nullptr;
 201     TextureState* mTextureState = nullptr;
 202     Program* mProgram = nullptr; // note: object owned by ProgramCache
 203
 204 }; // class Caches
 205
 206 }; // namespace uirenderer
 207 }; // namespace android
 208
 209 #endif // ANDROID_HWUI_CACHES_H