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 #ifndef LOG_TAG 21 #define LOG_TAG "OpenGLRenderer" 22 #endif 23 24 #include <vector> 25 26 #include <GLES3/gl3.h> 27 28 #include <utils/KeyedVector.h> 29 #include <utils/Singleton.h> 30 #include <utils/Vector.h> 31 32 #include <cutils/compiler.h> 33 34 #include "thread/TaskProcessor.h" 35 #include "thread/TaskManager.h" 36 37 #include "AssetAtlas.h" 38 #include "Extensions.h" 39 #include "FontRenderer.h" 40 #include "GammaFontRenderer.h" 41 #include "TextureCache.h" 42 #include "LayerCache.h" 43 #include "RenderBufferCache.h" 44 #include "GradientCache.h" 45 #include "PatchCache.h" 46 #include "ProgramCache.h" 47 #include "PathCache.h" 48 #include "TessellationCache.h" 49 #include "TextDropShadowCache.h" 50 #include "FboCache.h" 51 #include "ResourceCache.h" 52 #include "Stencil.h" 53 #include "Dither.h" 54 55 namespace android { 56 namespace uirenderer { 57 58 /////////////////////////////////////////////////////////////////////////////// 59 // Globals 60 /////////////////////////////////////////////////////////////////////////////// 61 62 // GL ES 2.0 defines that at least 16 texture units must be supported 63 #define REQUIRED_TEXTURE_UNITS_COUNT 3 64 65 // Maximum number of quads that pre-allocated meshes can draw 66 static const uint32_t gMaxNumberOfQuads = 2048; 67 68 // Generates simple and textured vertices 69 #define FV(x, y, u, v) { x, y, u, v } 70 71 // This array is never used directly but used as a memcpy source in the 72 // OpenGLRenderer constructor 73 static const TextureVertex gMeshVertices[] = { 74 FV(0.0f, 0.0f, 0.0f, 0.0f), 75 FV(1.0f, 0.0f, 1.0f, 0.0f), 76 FV(0.0f, 1.0f, 0.0f, 1.0f), 77 FV(1.0f, 1.0f, 1.0f, 1.0f) 78 }; 79 static const GLsizei gMeshStride = sizeof(TextureVertex); 80 static const GLsizei gVertexStride = sizeof(Vertex); 81 static const GLsizei gAlphaVertexStride = sizeof(AlphaVertex); 82 static const GLsizei gMeshTextureOffset = 2 * sizeof(float); 83 static const GLsizei gVertexAlphaOffset = 2 * sizeof(float); 84 static const GLsizei gVertexAAWidthOffset = 2 * sizeof(float); 85 static const GLsizei gVertexAALengthOffset = 3 * sizeof(float); 86 static const GLsizei gMeshCount = 4; 87 88 // Must define as many texture units as specified by REQUIRED_TEXTURE_UNITS_COUNT 89 static const GLenum gTextureUnits[] = { 90 GL_TEXTURE0, 91 GL_TEXTURE1, 92 GL_TEXTURE2 93 }; 94 95 /////////////////////////////////////////////////////////////////////////////// 96 // Debug 97 /////////////////////////////////////////////////////////////////////////////// 98 99 struct CacheLogger { 100 CacheLogger() { 101 INIT_LOGD("Creating OpenGL renderer caches"); 102 } 103 }; // struct CacheLogger 104 105 /////////////////////////////////////////////////////////////////////////////// 106 // Caches 107 /////////////////////////////////////////////////////////////////////////////// 108 109 class RenderNode; 110 class RenderState; 111 112 class ANDROID_API Caches: public Singleton<Caches> { 113 Caches(); 114 115 friend class Singleton<Caches>; 116 117 CacheLogger mLogger; 118 119 public: 120 enum FlushMode { 121 kFlushMode_Layers = 0, 122 kFlushMode_Moderate, 123 kFlushMode_Full 124 }; 125 126 /** 127 * Initialize caches. 128 */ 129 bool init(); 130 131 /** 132 * Initialize global system properties. 133 */ 134 bool initProperties(); 135 136 void setRenderState(RenderState* renderState) { mRenderState = renderState; } 137 138 /** 139 * Flush the cache. 140 * 141 * @param mode Indicates how much of the cache should be flushed 142 */ 143 void flush(FlushMode mode); 144 145 /** 146 * Destroys all resources associated with this cache. This should 147 * be called after a flush(kFlushMode_Full). 148 */ 149 void terminate(); 150 151 /** 152 * Indicates whether the renderer is in debug mode. 153 * This debug mode provides limited information to app developers. 154 */ 155 DebugLevel getDebugLevel() const { 156 return mDebugLevel; 157 } 158 159 /** 160 * Returns a non-premultiplied ARGB color for the specified 161 * amount of overdraw (1 for 1x, 2 for 2x, etc.) 162 */ 163 uint32_t getOverdrawColor(uint32_t amount) const; 164 165 /** 166 * Call this on each frame to ensure that garbage is deleted from 167 * GPU memory. 168 */ 169 void clearGarbage(); 170 171 /** 172 * Can be used to delete a layer from a non EGL thread. 173 */ 174 void deleteLayerDeferred(Layer* layer); 175 176 /** 177 * Binds the VBO used to render simple textured quads. 178 */ 179 bool bindMeshBuffer(); 180 181 /** 182 * Binds the specified VBO if needed. 183 */ 184 bool bindMeshBuffer(const GLuint buffer); 185 186 /** 187 * Unbinds the VBO used to render simple textured quads. 188 */ 189 bool unbindMeshBuffer(); 190 191 /** 192 * Binds a global indices buffer that can draw up to 193 * gMaxNumberOfQuads quads. 194 */ 195 bool bindQuadIndicesBuffer(); 196 bool bindShadowIndicesBuffer(); 197 bool unbindIndicesBuffer(); 198 199 /** 200 * Binds the specified buffer as the current GL unpack pixel buffer. 201 */ 202 bool bindPixelBuffer(const GLuint buffer); 203 204 /** 205 * Resets the current unpack pixel buffer to 0 (default value.) 206 */ 207 bool unbindPixelBuffer(); 208 209 /** 210 * Binds an attrib to the specified float vertex pointer. 211 * Assumes a stride of gMeshStride and a size of 2. 212 */ 213 void bindPositionVertexPointer(bool force, const GLvoid* vertices, GLsizei stride = gMeshStride); 214 215 /** 216 * Binds an attrib to the specified float vertex pointer. 217 * Assumes a stride of gMeshStride and a size of 2. 218 */ 219 void bindTexCoordsVertexPointer(bool force, const GLvoid* vertices, GLsizei stride = gMeshStride); 220 221 /** 222 * Resets the vertex pointers. 223 */ 224 void resetVertexPointers(); 225 void resetTexCoordsVertexPointer(); 226 227 void enableTexCoordsVertexArray(); 228 void disableTexCoordsVertexArray(); 229 230 /** 231 * Activate the specified texture unit. The texture unit must 232 * be specified using an integer number (0 for GL_TEXTURE0 etc.) 233 */ 234 void activeTexture(GLuint textureUnit); 235 236 /** 237 * Invalidate the cached value of the active texture unit. 238 */ 239 void resetActiveTexture(); 240 241 /** 242 * Binds the specified texture as a GL_TEXTURE_2D texture. 243 * All texture bindings must be performed with this method or 244 * bindTexture(GLenum, GLuint). 245 */ 246 void bindTexture(GLuint texture); 247 248 /** 249 * Binds the specified texture with the specified render target. 250 * All texture bindings must be performed with this method or 251 * bindTexture(GLuint). 252 */ 253 void bindTexture(GLenum target, GLuint texture); 254 255 /** 256 * Deletes the specified texture and clears it from the cache 257 * of bound textures. 258 * All textures must be deleted using this method. 259 */ 260 void deleteTexture(GLuint texture); 261 262 /** 263 * Signals that the cache of bound textures should be cleared. 264 * Other users of the context may have altered which textures are bound. 265 */ 266 void resetBoundTextures(); 267 268 /** 269 * Clear the cache of bound textures. 270 */ 271 void unbindTexture(GLuint texture); 272 273 /** 274 * Sets the scissor for the current surface. 275 */ 276 bool setScissor(GLint x, GLint y, GLint width, GLint height); 277 278 /** 279 * Resets the scissor state. 280 */ 281 void resetScissor(); 282 283 bool enableScissor(); 284 bool disableScissor(); 285 void setScissorEnabled(bool enabled); 286 287 void startTiling(GLuint x, GLuint y, GLuint width, GLuint height, bool discard); 288 void endTiling(); 289 290 /** 291 * Returns the mesh used to draw regions. Calling this method will 292 * bind a VBO of type GL_ELEMENT_ARRAY_BUFFER that contains the 293 * indices for the region mesh. 294 */ 295 TextureVertex* getRegionMesh(); 296 297 /** 298 * Displays the memory usage of each cache and the total sum. 299 */ 300 void dumpMemoryUsage(); 301 void dumpMemoryUsage(String8& log); 302 303 bool hasRegisteredFunctors(); 304 void registerFunctors(uint32_t functorCount); 305 void unregisterFunctors(uint32_t functorCount); 306 307 bool blend; 308 GLenum lastSrcMode; 309 GLenum lastDstMode; 310 Program* currentProgram; 311 bool scissorEnabled; 312 313 bool drawDeferDisabled; 314 bool drawReorderDisabled; 315 316 // VBO to draw with 317 GLuint meshBuffer; 318 319 // Misc 320 GLint maxTextureSize; 321 322 // Debugging 323 bool debugLayersUpdates; 324 bool debugOverdraw; 325 326 enum StencilClipDebug { 327 kStencilHide, 328 kStencilShowHighlight, 329 kStencilShowRegion 330 }; 331 StencilClipDebug debugStencilClip; 332 333 TextureCache textureCache; 334 LayerCache layerCache; 335 RenderBufferCache renderBufferCache; 336 GradientCache gradientCache; 337 ProgramCache programCache; 338 PathCache pathCache; 339 PatchCache patchCache; 340 TessellationCache tessellationCache; 341 TextDropShadowCache dropShadowCache; 342 FboCache fboCache; 343 344 GammaFontRenderer* fontRenderer; 345 346 TaskManager tasks; 347 348 Dither dither; 349 Stencil stencil; 350 351 bool gpuPixelBuffersEnabled; 352 353 // Debug methods 354 PFNGLINSERTEVENTMARKEREXTPROC eventMark; 355 PFNGLPUSHGROUPMARKEREXTPROC startMark; 356 PFNGLPOPGROUPMARKEREXTPROC endMark; 357 358 PFNGLLABELOBJECTEXTPROC setLabel; 359 PFNGLGETOBJECTLABELEXTPROC getLabel; 360 361 // TEMPORARY properties 362 void initTempProperties(); 363 void setTempProperty(const char* name, const char* value); 364 365 float propertyLightDiameter; 366 float propertyLightPosY; 367 float propertyLightPosZ; 368 float propertyAmbientRatio; 369 int propertyAmbientShadowStrength; 370 int propertySpotShadowStrength; 371 372 private: 373 enum OverdrawColorSet { 374 kColorSet_Default = 0, 375 kColorSet_Deuteranomaly 376 }; 377 378 void initFont(); 379 void initExtensions(); 380 void initConstraints(); 381 void initStaticProperties(); 382 383 bool bindIndicesBufferInternal(const GLuint buffer); 384 385 static void eventMarkNull(GLsizei length, const GLchar* marker) { } 386 static void startMarkNull(GLsizei length, const GLchar* marker) { } 387 static void endMarkNull() { } 388 389 static void setLabelNull(GLenum type, uint object, GLsizei length, 390 const char* label) { } 391 static void getLabelNull(GLenum type, uint object, GLsizei bufferSize, 392 GLsizei* length, char* label) { 393 if (length) *length = 0; 394 if (label) *label = '\0'; 395 } 396 397 GLuint mCurrentBuffer; 398 GLuint mCurrentIndicesBuffer; 399 GLuint mCurrentPixelBuffer; 400 const void* mCurrentPositionPointer; 401 GLsizei mCurrentPositionStride; 402 const void* mCurrentTexCoordsPointer; 403 GLsizei mCurrentTexCoordsStride; 404 405 bool mTexCoordsArrayEnabled; 406 407 GLuint mTextureUnit; 408 409 GLint mScissorX; 410 GLint mScissorY; 411 GLint mScissorWidth; 412 GLint mScissorHeight; 413 414 Extensions& mExtensions; 415 416 // Used to render layers 417 TextureVertex* mRegionMesh; 418 419 // Global index buffer 420 GLuint mMeshIndices; 421 GLuint mShadowStripsIndices; 422 423 mutable Mutex mGarbageLock; 424 Vector<Layer*> mLayerGarbage; 425 426 DebugLevel mDebugLevel; 427 bool mInitialized; 428 429 uint32_t mFunctorsCount; 430 431 // Caches texture bindings for the GL_TEXTURE_2D target 432 GLuint mBoundTextures[REQUIRED_TEXTURE_UNITS_COUNT]; 433 434 OverdrawColorSet mOverdrawDebugColorSet; 435 436 RenderState* mRenderState; 437 }; // class Caches 438 439 }; // namespace uirenderer 440 }; // namespace android 441 442 #endif // ANDROID_HWUI_CACHES_H 443
