Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 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 | #define LOG_TAG "OpenGLRenderer" |
| 18 | |
Romain Guy | c15008e | 2010-11-10 11:59:15 -0800 | [diff] [blame] | 19 | #include <utils/Log.h> |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 20 | #include <utils/String8.h> |
Romain Guy | c15008e | 2010-11-10 11:59:15 -0800 | [diff] [blame] | 21 | |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 22 | #include "Caches.h" |
Romain Guy | bb0acdf | 2012-03-05 13:44:35 -0800 | [diff] [blame] | 23 | #include "DisplayListRenderer.h" |
Romain Guy | e190aa6 | 2010-11-10 19:01:29 -0800 | [diff] [blame] | 24 | #include "Properties.h" |
Romain Guy | 09b7c91 | 2011-02-02 20:28:09 -0800 | [diff] [blame] | 25 | #include "LayerRenderer.h" |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 26 | |
| 27 | namespace android { |
| 28 | |
| 29 | #ifdef USE_OPENGL_RENDERER |
| 30 | using namespace uirenderer; |
| 31 | ANDROID_SINGLETON_STATIC_INSTANCE(Caches); |
| 32 | #endif |
| 33 | |
| 34 | namespace uirenderer { |
| 35 | |
| 36 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | bdf7609 | 2011-07-18 15:00:43 -0700 | [diff] [blame] | 37 | // Macros |
| 38 | /////////////////////////////////////////////////////////////////////////////// |
| 39 | |
| 40 | #if DEBUG_CACHE_FLUSH |
Steve Block | 5baa3a6 | 2011-12-20 16:23:08 +0000 | [diff] [blame] | 41 | #define FLUSH_LOGD(...) ALOGD(__VA_ARGS__) |
Romain Guy | bdf7609 | 2011-07-18 15:00:43 -0700 | [diff] [blame] | 42 | #else |
| 43 | #define FLUSH_LOGD(...) |
| 44 | #endif |
| 45 | |
| 46 | /////////////////////////////////////////////////////////////////////////////// |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 47 | // Constructors/destructor |
| 48 | /////////////////////////////////////////////////////////////////////////////// |
| 49 | |
Romain Guy | 8ff6b9e | 2011-11-09 20:10:18 -0800 | [diff] [blame] | 50 | Caches::Caches(): Singleton<Caches>(), mInitialized(false) { |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 51 | GLint maxTextureUnits; |
| 52 | glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTextureUnits); |
| 53 | if (maxTextureUnits < REQUIRED_TEXTURE_UNITS_COUNT) { |
Steve Block | 8564c8d | 2012-01-05 23:22:43 +0000 | [diff] [blame] | 54 | ALOGW("At least %d texture units are required!", REQUIRED_TEXTURE_UNITS_COUNT); |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 55 | } |
| 56 | |
Romain Guy | 746b740 | 2010-10-26 16:27:31 -0700 | [diff] [blame] | 57 | glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize); |
| 58 | |
Romain Guy | 13631f3 | 2012-01-30 17:41:55 -0800 | [diff] [blame] | 59 | if (extensions.hasDebugMarker()) { |
| 60 | eventMark = glInsertEventMarkerEXT; |
| 61 | startMark = glPushGroupMarkerEXT; |
| 62 | endMark = glPopGroupMarkerEXT; |
| 63 | } else { |
| 64 | eventMark = eventMarkNull; |
| 65 | startMark = startMarkNull; |
| 66 | endMark = endMarkNull; |
| 67 | } |
| 68 | |
Romain Guy | 8ff6b9e | 2011-11-09 20:10:18 -0800 | [diff] [blame] | 69 | init(); |
Romain Guy | e190aa6 | 2010-11-10 19:01:29 -0800 | [diff] [blame] | 70 | |
| 71 | mDebugLevel = readDebugLevel(); |
Steve Block | 5baa3a6 | 2011-12-20 16:23:08 +0000 | [diff] [blame] | 72 | ALOGD("Enabling debug mode %d", mDebugLevel); |
Romain Guy | 7230a74 | 2011-01-10 22:26:16 -0800 | [diff] [blame] | 73 | |
| 74 | #if RENDER_LAYERS_AS_REGIONS |
Romain Guy | 02ccac6 | 2011-06-24 13:20:23 -0700 | [diff] [blame] | 75 | INIT_LOGD("Layers will be composited as regions"); |
Romain Guy | 7230a74 | 2011-01-10 22:26:16 -0800 | [diff] [blame] | 76 | #endif |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 77 | } |
| 78 | |
Romain Guy | 8ff6b9e | 2011-11-09 20:10:18 -0800 | [diff] [blame] | 79 | void Caches::init() { |
| 80 | if (mInitialized) return; |
| 81 | |
| 82 | glGenBuffers(1, &meshBuffer); |
| 83 | glBindBuffer(GL_ARRAY_BUFFER, meshBuffer); |
| 84 | glBufferData(GL_ARRAY_BUFFER, sizeof(gMeshVertices), gMeshVertices, GL_STATIC_DRAW); |
| 85 | |
| 86 | mCurrentBuffer = meshBuffer; |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 87 | mCurrentIndicesBuffer = 0; |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 88 | mCurrentPositionPointer = this; |
| 89 | mCurrentTexCoordsPointer = this; |
| 90 | |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 91 | mTexCoordsArrayEnabled = false; |
| 92 | |
Romain Guy | 8f85e80 | 2011-12-14 19:23:32 -0800 | [diff] [blame] | 93 | mScissorX = mScissorY = mScissorWidth = mScissorHeight = 0; |
| 94 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 95 | glActiveTexture(gTextureUnits[0]); |
| 96 | mTextureUnit = 0; |
| 97 | |
Romain Guy | 8ff6b9e | 2011-11-09 20:10:18 -0800 | [diff] [blame] | 98 | mRegionMesh = NULL; |
| 99 | |
| 100 | blend = false; |
| 101 | lastSrcMode = GL_ZERO; |
| 102 | lastDstMode = GL_ZERO; |
| 103 | currentProgram = NULL; |
| 104 | |
| 105 | mInitialized = true; |
| 106 | } |
| 107 | |
| 108 | void Caches::terminate() { |
| 109 | if (!mInitialized) return; |
| 110 | |
| 111 | glDeleteBuffers(1, &meshBuffer); |
| 112 | mCurrentBuffer = 0; |
| 113 | |
| 114 | glDeleteBuffers(1, &mRegionMeshIndices); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 115 | delete[] mRegionMesh; |
Romain Guy | 8ff6b9e | 2011-11-09 20:10:18 -0800 | [diff] [blame] | 116 | mRegionMesh = NULL; |
| 117 | |
| 118 | fboCache.clear(); |
| 119 | |
| 120 | programCache.clear(); |
| 121 | currentProgram = NULL; |
| 122 | |
| 123 | mInitialized = false; |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 124 | } |
| 125 | |
| 126 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | c15008e | 2010-11-10 11:59:15 -0800 | [diff] [blame] | 127 | // Debug |
| 128 | /////////////////////////////////////////////////////////////////////////////// |
| 129 | |
| 130 | void Caches::dumpMemoryUsage() { |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 131 | String8 stringLog; |
| 132 | dumpMemoryUsage(stringLog); |
Steve Block | 5baa3a6 | 2011-12-20 16:23:08 +0000 | [diff] [blame] | 133 | ALOGD("%s", stringLog.string()); |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | void Caches::dumpMemoryUsage(String8 &log) { |
| 137 | log.appendFormat("Current memory usage / total memory usage (bytes):\n"); |
| 138 | log.appendFormat(" TextureCache %8d / %8d\n", |
| 139 | textureCache.getSize(), textureCache.getMaxSize()); |
| 140 | log.appendFormat(" LayerCache %8d / %8d\n", |
| 141 | layerCache.getSize(), layerCache.getMaxSize()); |
| 142 | log.appendFormat(" GradientCache %8d / %8d\n", |
| 143 | gradientCache.getSize(), gradientCache.getMaxSize()); |
| 144 | log.appendFormat(" PathCache %8d / %8d\n", |
| 145 | pathCache.getSize(), pathCache.getMaxSize()); |
| 146 | log.appendFormat(" CircleShapeCache %8d / %8d\n", |
Romain Guy | 01d58e4 | 2011-01-19 21:54:02 -0800 | [diff] [blame] | 147 | circleShapeCache.getSize(), circleShapeCache.getMaxSize()); |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 148 | log.appendFormat(" OvalShapeCache %8d / %8d\n", |
Romain Guy | 2fc941e | 2011-02-03 15:06:05 -0800 | [diff] [blame] | 149 | ovalShapeCache.getSize(), ovalShapeCache.getMaxSize()); |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 150 | log.appendFormat(" RoundRectShapeCache %8d / %8d\n", |
Romain Guy | 01d58e4 | 2011-01-19 21:54:02 -0800 | [diff] [blame] | 151 | roundRectShapeCache.getSize(), roundRectShapeCache.getMaxSize()); |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 152 | log.appendFormat(" RectShapeCache %8d / %8d\n", |
Romain Guy | 2fc941e | 2011-02-03 15:06:05 -0800 | [diff] [blame] | 153 | rectShapeCache.getSize(), rectShapeCache.getMaxSize()); |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 154 | log.appendFormat(" ArcShapeCache %8d / %8d\n", |
Romain Guy | 2fc941e | 2011-02-03 15:06:05 -0800 | [diff] [blame] | 155 | arcShapeCache.getSize(), arcShapeCache.getMaxSize()); |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 156 | log.appendFormat(" TextDropShadowCache %8d / %8d\n", dropShadowCache.getSize(), |
Romain Guy | c15008e | 2010-11-10 11:59:15 -0800 | [diff] [blame] | 157 | dropShadowCache.getMaxSize()); |
| 158 | for (uint32_t i = 0; i < fontRenderer.getFontRendererCount(); i++) { |
| 159 | const uint32_t size = fontRenderer.getFontRendererSize(i); |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 160 | log.appendFormat(" FontRenderer %d %8d / %8d\n", i, size, size); |
Romain Guy | c15008e | 2010-11-10 11:59:15 -0800 | [diff] [blame] | 161 | } |
Romain Guy | d2ba50a | 2011-05-27 10:21:07 -0700 | [diff] [blame] | 162 | log.appendFormat("Other:\n"); |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 163 | log.appendFormat(" FboCache %8d / %8d\n", |
| 164 | fboCache.getSize(), fboCache.getMaxSize()); |
| 165 | log.appendFormat(" PatchCache %8d / %8d\n", |
| 166 | patchCache.getSize(), patchCache.getMaxSize()); |
Romain Guy | c15008e | 2010-11-10 11:59:15 -0800 | [diff] [blame] | 167 | |
| 168 | uint32_t total = 0; |
| 169 | total += textureCache.getSize(); |
| 170 | total += layerCache.getSize(); |
| 171 | total += gradientCache.getSize(); |
| 172 | total += pathCache.getSize(); |
| 173 | total += dropShadowCache.getSize(); |
Romain Guy | 2fc941e | 2011-02-03 15:06:05 -0800 | [diff] [blame] | 174 | total += roundRectShapeCache.getSize(); |
| 175 | total += circleShapeCache.getSize(); |
| 176 | total += ovalShapeCache.getSize(); |
| 177 | total += rectShapeCache.getSize(); |
| 178 | total += arcShapeCache.getSize(); |
Romain Guy | c15008e | 2010-11-10 11:59:15 -0800 | [diff] [blame] | 179 | for (uint32_t i = 0; i < fontRenderer.getFontRendererCount(); i++) { |
| 180 | total += fontRenderer.getFontRendererSize(i); |
| 181 | } |
| 182 | |
Chet Haase | 9c1e23b | 2011-03-24 10:51:31 -0700 | [diff] [blame] | 183 | log.appendFormat("Total memory usage:\n"); |
| 184 | log.appendFormat(" %d bytes, %.2f MB\n", total, total / 1024.0f / 1024.0f); |
Romain Guy | c15008e | 2010-11-10 11:59:15 -0800 | [diff] [blame] | 185 | } |
| 186 | |
| 187 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | fe48f65 | 2010-11-11 15:36:56 -0800 | [diff] [blame] | 188 | // Memory management |
| 189 | /////////////////////////////////////////////////////////////////////////////// |
| 190 | |
| 191 | void Caches::clearGarbage() { |
| 192 | textureCache.clearGarbage(); |
Romain Guy | fe48f65 | 2010-11-11 15:36:56 -0800 | [diff] [blame] | 193 | pathCache.clearGarbage(); |
Romain Guy | 57066eb | 2011-01-12 12:53:32 -0800 | [diff] [blame] | 194 | |
| 195 | Mutex::Autolock _l(mGarbageLock); |
| 196 | |
Romain Guy | ada830f | 2011-01-13 12:13:20 -0800 | [diff] [blame] | 197 | size_t count = mLayerGarbage.size(); |
Romain Guy | 57066eb | 2011-01-12 12:53:32 -0800 | [diff] [blame] | 198 | for (size_t i = 0; i < count; i++) { |
Romain Guy | ada830f | 2011-01-13 12:13:20 -0800 | [diff] [blame] | 199 | Layer* layer = mLayerGarbage.itemAt(i); |
Romain Guy | 09b7c91 | 2011-02-02 20:28:09 -0800 | [diff] [blame] | 200 | LayerRenderer::destroyLayer(layer); |
Romain Guy | 57066eb | 2011-01-12 12:53:32 -0800 | [diff] [blame] | 201 | } |
Romain Guy | ada830f | 2011-01-13 12:13:20 -0800 | [diff] [blame] | 202 | mLayerGarbage.clear(); |
Romain Guy | bb0acdf | 2012-03-05 13:44:35 -0800 | [diff] [blame] | 203 | |
| 204 | count = mDisplayListGarbage.size(); |
| 205 | for (size_t i = 0; i < count; i++) { |
| 206 | DisplayList* displayList = mDisplayListGarbage.itemAt(i); |
| 207 | delete displayList; |
| 208 | } |
| 209 | mDisplayListGarbage.clear(); |
Romain Guy | 57066eb | 2011-01-12 12:53:32 -0800 | [diff] [blame] | 210 | } |
| 211 | |
Romain Guy | ada830f | 2011-01-13 12:13:20 -0800 | [diff] [blame] | 212 | void Caches::deleteLayerDeferred(Layer* layer) { |
Romain Guy | 57066eb | 2011-01-12 12:53:32 -0800 | [diff] [blame] | 213 | Mutex::Autolock _l(mGarbageLock); |
Romain Guy | ada830f | 2011-01-13 12:13:20 -0800 | [diff] [blame] | 214 | mLayerGarbage.push(layer); |
Romain Guy | fe48f65 | 2010-11-11 15:36:56 -0800 | [diff] [blame] | 215 | } |
| 216 | |
Romain Guy | bb0acdf | 2012-03-05 13:44:35 -0800 | [diff] [blame] | 217 | void Caches::deleteDisplayListDeferred(DisplayList* displayList) { |
| 218 | Mutex::Autolock _l(mGarbageLock); |
| 219 | mDisplayListGarbage.push(displayList); |
| 220 | } |
| 221 | |
Romain Guy | bdf7609 | 2011-07-18 15:00:43 -0700 | [diff] [blame] | 222 | void Caches::flush(FlushMode mode) { |
| 223 | FLUSH_LOGD("Flushing caches (mode %d)", mode); |
| 224 | |
| 225 | clearGarbage(); |
| 226 | |
| 227 | switch (mode) { |
| 228 | case kFlushMode_Full: |
| 229 | textureCache.clear(); |
| 230 | patchCache.clear(); |
| 231 | dropShadowCache.clear(); |
| 232 | gradientCache.clear(); |
Romain Guy | eca0ca2 | 2011-11-04 15:12:29 -0700 | [diff] [blame] | 233 | fontRenderer.clear(); |
Romain Guy | bdf7609 | 2011-07-18 15:00:43 -0700 | [diff] [blame] | 234 | // fall through |
| 235 | case kFlushMode_Moderate: |
Romain Guy | eca0ca2 | 2011-11-04 15:12:29 -0700 | [diff] [blame] | 236 | fontRenderer.flush(); |
| 237 | textureCache.flush(); |
Romain Guy | bdf7609 | 2011-07-18 15:00:43 -0700 | [diff] [blame] | 238 | pathCache.clear(); |
| 239 | roundRectShapeCache.clear(); |
| 240 | circleShapeCache.clear(); |
| 241 | ovalShapeCache.clear(); |
| 242 | rectShapeCache.clear(); |
| 243 | arcShapeCache.clear(); |
Romain Guy | 6d7475d | 2011-07-27 16:28:21 -0700 | [diff] [blame] | 244 | // fall through |
| 245 | case kFlushMode_Layers: |
| 246 | layerCache.clear(); |
Romain Guy | bdf7609 | 2011-07-18 15:00:43 -0700 | [diff] [blame] | 247 | break; |
| 248 | } |
| 249 | } |
| 250 | |
Romain Guy | fe48f65 | 2010-11-11 15:36:56 -0800 | [diff] [blame] | 251 | /////////////////////////////////////////////////////////////////////////////// |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 252 | // VBO |
| 253 | /////////////////////////////////////////////////////////////////////////////// |
| 254 | |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 255 | bool Caches::bindMeshBuffer() { |
| 256 | return bindMeshBuffer(meshBuffer); |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 257 | } |
| 258 | |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 259 | bool Caches::bindMeshBuffer(const GLuint buffer) { |
Romain Guy | 9bca479 | 2010-10-25 18:42:25 -0700 | [diff] [blame] | 260 | if (mCurrentBuffer != buffer) { |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 261 | glBindBuffer(GL_ARRAY_BUFFER, buffer); |
Romain Guy | 9bca479 | 2010-10-25 18:42:25 -0700 | [diff] [blame] | 262 | mCurrentBuffer = buffer; |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 263 | return true; |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 264 | } |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 265 | return false; |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 266 | } |
| 267 | |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 268 | bool Caches::unbindMeshBuffer() { |
Romain Guy | 9bca479 | 2010-10-25 18:42:25 -0700 | [diff] [blame] | 269 | if (mCurrentBuffer) { |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 270 | glBindBuffer(GL_ARRAY_BUFFER, 0); |
Romain Guy | 9bca479 | 2010-10-25 18:42:25 -0700 | [diff] [blame] | 271 | mCurrentBuffer = 0; |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 272 | return true; |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 273 | } |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 274 | return false; |
| 275 | } |
| 276 | |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 277 | bool Caches::bindIndicesBuffer(const GLuint buffer) { |
| 278 | if (mCurrentIndicesBuffer != buffer) { |
| 279 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer); |
| 280 | mCurrentIndicesBuffer = buffer; |
| 281 | return true; |
| 282 | } |
| 283 | return false; |
| 284 | } |
| 285 | |
| 286 | bool Caches::unbindIndicesBuffer() { |
| 287 | if (mCurrentIndicesBuffer) { |
| 288 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); |
| 289 | mCurrentIndicesBuffer = 0; |
| 290 | return true; |
| 291 | } |
| 292 | return false; |
| 293 | } |
| 294 | |
Romain Guy | f3a910b4 | 2011-12-12 20:35:21 -0800 | [diff] [blame] | 295 | void Caches::bindPositionVertexPointer(bool force, GLuint slot, GLvoid* vertices, GLsizei stride) { |
| 296 | if (force || vertices != mCurrentPositionPointer) { |
| 297 | glVertexAttribPointer(slot, 2, GL_FLOAT, GL_FALSE, stride, vertices); |
| 298 | mCurrentPositionPointer = vertices; |
| 299 | } |
| 300 | } |
| 301 | |
| 302 | void Caches::bindTexCoordsVertexPointer(bool force, GLuint slot, GLvoid* vertices) { |
| 303 | if (force || vertices != mCurrentTexCoordsPointer) { |
| 304 | glVertexAttribPointer(slot, 2, GL_FLOAT, GL_FALSE, gMeshStride, vertices); |
| 305 | mCurrentTexCoordsPointer = vertices; |
| 306 | } |
| 307 | } |
| 308 | |
| 309 | void Caches::resetVertexPointers() { |
| 310 | mCurrentPositionPointer = this; |
| 311 | mCurrentTexCoordsPointer = this; |
| 312 | } |
| 313 | |
| 314 | void Caches::resetTexCoordsVertexPointer() { |
| 315 | mCurrentTexCoordsPointer = this; |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 316 | } |
| 317 | |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 318 | void Caches::enableTexCoordsVertexArray() { |
| 319 | if (!mTexCoordsArrayEnabled) { |
| 320 | glEnableVertexAttribArray(Program::kBindingTexCoords); |
Romain Guy | ec31f83 | 2011-12-13 18:39:19 -0800 | [diff] [blame] | 321 | mCurrentTexCoordsPointer = this; |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 322 | mTexCoordsArrayEnabled = true; |
| 323 | } |
| 324 | } |
| 325 | |
| 326 | void Caches::disbaleTexCoordsVertexArray() { |
| 327 | if (mTexCoordsArrayEnabled) { |
| 328 | glDisableVertexAttribArray(Program::kBindingTexCoords); |
| 329 | mTexCoordsArrayEnabled = false; |
| 330 | } |
| 331 | } |
| 332 | |
Romain Guy | a1d3c91 | 2011-12-13 14:55:06 -0800 | [diff] [blame] | 333 | void Caches::activeTexture(GLuint textureUnit) { |
| 334 | if (mTextureUnit != textureUnit) { |
| 335 | glActiveTexture(gTextureUnits[textureUnit]); |
| 336 | mTextureUnit = textureUnit; |
| 337 | } |
| 338 | } |
| 339 | |
Romain Guy | 8f85e80 | 2011-12-14 19:23:32 -0800 | [diff] [blame] | 340 | void Caches::setScissor(GLint x, GLint y, GLint width, GLint height) { |
| 341 | if (x != mScissorX || y != mScissorY || width != mScissorWidth || height != mScissorHeight) { |
| 342 | glScissor(x, y, width, height); |
| 343 | |
| 344 | mScissorX = x; |
| 345 | mScissorY = y; |
| 346 | mScissorWidth = width; |
| 347 | mScissorHeight = height; |
| 348 | } |
| 349 | } |
| 350 | |
Romain Guy | 82bc7a7 | 2012-01-03 14:13:39 -0800 | [diff] [blame] | 351 | void Caches::resetScissor() { |
| 352 | mScissorX = mScissorY = mScissorWidth = mScissorHeight = 0; |
| 353 | } |
| 354 | |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 355 | TextureVertex* Caches::getRegionMesh() { |
| 356 | // Create the mesh, 2 triangles and 4 vertices per rectangle in the region |
| 357 | if (!mRegionMesh) { |
| 358 | mRegionMesh = new TextureVertex[REGION_MESH_QUAD_COUNT * 4]; |
| 359 | |
| 360 | uint16_t* regionIndices = new uint16_t[REGION_MESH_QUAD_COUNT * 6]; |
| 361 | for (int i = 0; i < REGION_MESH_QUAD_COUNT; i++) { |
| 362 | uint16_t quad = i * 4; |
| 363 | int index = i * 6; |
| 364 | regionIndices[index ] = quad; // top-left |
| 365 | regionIndices[index + 1] = quad + 1; // top-right |
| 366 | regionIndices[index + 2] = quad + 2; // bottom-left |
| 367 | regionIndices[index + 3] = quad + 2; // bottom-left |
| 368 | regionIndices[index + 4] = quad + 1; // top-right |
| 369 | regionIndices[index + 5] = quad + 3; // bottom-right |
| 370 | } |
| 371 | |
| 372 | glGenBuffers(1, &mRegionMeshIndices); |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 373 | bindIndicesBuffer(mRegionMeshIndices); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 374 | glBufferData(GL_ELEMENT_ARRAY_BUFFER, REGION_MESH_QUAD_COUNT * 6 * sizeof(uint16_t), |
| 375 | regionIndices, GL_STATIC_DRAW); |
| 376 | |
| 377 | delete[] regionIndices; |
| 378 | } else { |
Romain Guy | 15bc643 | 2011-12-13 13:11:32 -0800 | [diff] [blame] | 379 | bindIndicesBuffer(mRegionMeshIndices); |
Romain Guy | 5b3b352 | 2010-10-27 18:57:51 -0700 | [diff] [blame] | 380 | } |
| 381 | |
| 382 | return mRegionMesh; |
| 383 | } |
| 384 | |
Chet Haase | dd78cca | 2010-10-22 18:59:26 -0700 | [diff] [blame] | 385 | }; // namespace uirenderer |
| 386 | }; // namespace android |