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