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
19 #include <utils/Log.h>
20 #include <utils/String8.h>
21
22 #include "Caches.h"
23 #include "DisplayListRenderer.h"
24 #include "Properties.h"
25 #include "LayerRenderer.h"
26 #include "ShadowTessellator.h"
27 #include "RenderState.h"
28
29 namespace android {
30
31 #ifdef USE_OPENGL_RENDERER
32 using namespace uirenderer;
33 ANDROID_SINGLETON_STATIC_INSTANCE(Caches);
34 #endif
35
36 namespace uirenderer {
37
38 ///////////////////////////////////////////////////////////////////////////////
39 // Macros
40 ///////////////////////////////////////////////////////////////////////////////
41
42 #if DEBUG_CACHE_FLUSH
43 #define FLUSH_LOGD(...) ALOGD(__VA_ARGS__)
44 #else
45 #define FLUSH_LOGD(...)
46 #endif
47
48 ///////////////////////////////////////////////////////////////////////////////
49 // Constructors/destructor
50 ///////////////////////////////////////////////////////////////////////////////
51
Caches()52 Caches::Caches(): Singleton<Caches>(),
53 mExtensions(Extensions::getInstance()), mInitialized(false), mRenderState(NULL) {
54 init();
55 initFont();
56 initConstraints();
57 initProperties();
58 initStaticProperties();
59 initExtensions();
60 initTempProperties();
61
62 mDebugLevel = readDebugLevel();
63 ALOGD("Enabling debug mode %d", mDebugLevel);
64 }
65
init()66 bool Caches::init() {
67 if (mInitialized) return false;
68
69 ATRACE_NAME("Caches::init");
70
71 glGenBuffers(1, &meshBuffer);
72 glBindBuffer(GL_ARRAY_BUFFER, meshBuffer);
73 glBufferData(GL_ARRAY_BUFFER, sizeof(gMeshVertices), gMeshVertices, GL_STATIC_DRAW);
74
75 mCurrentBuffer = meshBuffer;
76 mCurrentIndicesBuffer = 0;
77 mCurrentPositionPointer = this;
78 mCurrentPositionStride = 0;
79 mCurrentTexCoordsPointer = this;
80 mCurrentPixelBuffer = 0;
81
82 mTexCoordsArrayEnabled = false;
83
84 glDisable(GL_SCISSOR_TEST);
85 scissorEnabled = false;
86 mScissorX = mScissorY = mScissorWidth = mScissorHeight = 0;
87
88 glActiveTexture(gTextureUnits[0]);
89 mTextureUnit = 0;
90
91 mRegionMesh = NULL;
92 mMeshIndices = 0;
93 mShadowStripsIndices = 0;
94 blend = false;
95 lastSrcMode = GL_ZERO;
96 lastDstMode = GL_ZERO;
97 currentProgram = NULL;
98
99 mFunctorsCount = 0;
100
101 debugLayersUpdates = false;
102 debugOverdraw = false;
103 debugStencilClip = kStencilHide;
104
105 patchCache.init(*this);
106
107 mInitialized = true;
108
109 resetBoundTextures();
110
111 return true;
112 }
113
initFont()114 void Caches::initFont() {
115 fontRenderer = GammaFontRenderer::createRenderer();
116 }
117
initExtensions()118 void Caches::initExtensions() {
119 if (mExtensions.hasDebugMarker()) {
120 eventMark = glInsertEventMarkerEXT;
121
122 startMark = glPushGroupMarkerEXT;
123 endMark = glPopGroupMarkerEXT;
124 } else {
125 eventMark = eventMarkNull;
126 startMark = startMarkNull;
127 endMark = endMarkNull;
128 }
129
130 if (mExtensions.hasDebugLabel() && (drawDeferDisabled || drawReorderDisabled)) {
131 setLabel = glLabelObjectEXT;
132 getLabel = glGetObjectLabelEXT;
133 } else {
134 setLabel = setLabelNull;
135 getLabel = getLabelNull;
136 }
137 }
138
initConstraints()139 void Caches::initConstraints() {
140 GLint maxTextureUnits;
141 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
142 if (maxTextureUnits < REQUIRED_TEXTURE_UNITS_COUNT) {
143 ALOGW("At least %d texture units are required!", REQUIRED_TEXTURE_UNITS_COUNT);
144 }
145
146 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
147 }
148
initStaticProperties()149 void Caches::initStaticProperties() {
150 gpuPixelBuffersEnabled = false;
151
152 // OpenGL ES 3.0+ specific features
153 if (mExtensions.hasPixelBufferObjects()) {
154 char property[PROPERTY_VALUE_MAX];
155 if (property_get(PROPERTY_ENABLE_GPU_PIXEL_BUFFERS, property, "true") > 0) {
156 gpuPixelBuffersEnabled = !strcmp(property, "true");
157 }
158 }
159 }
160
initProperties()161 bool Caches::initProperties() {
162 bool prevDebugLayersUpdates = debugLayersUpdates;
163 bool prevDebugOverdraw = debugOverdraw;
164 StencilClipDebug prevDebugStencilClip = debugStencilClip;
165
166 char property[PROPERTY_VALUE_MAX];
167 if (property_get(PROPERTY_DEBUG_LAYERS_UPDATES, property, NULL) > 0) {
168 INIT_LOGD(" Layers updates debug enabled: %s", property);
169 debugLayersUpdates = !strcmp(property, "true");
170 } else {
171 debugLayersUpdates = false;
172 }
173
174 debugOverdraw = false;
175 if (property_get(PROPERTY_DEBUG_OVERDRAW, property, NULL) > 0) {
176 INIT_LOGD(" Overdraw debug enabled: %s", property);
177 if (!strcmp(property, "show")) {
178 debugOverdraw = true;
179 mOverdrawDebugColorSet = kColorSet_Default;
180 } else if (!strcmp(property, "show_deuteranomaly")) {
181 debugOverdraw = true;
182 mOverdrawDebugColorSet = kColorSet_Deuteranomaly;
183 }
184 }
185
186 // See Properties.h for valid values
187 if (property_get(PROPERTY_DEBUG_STENCIL_CLIP, property, NULL) > 0) {
188 INIT_LOGD(" Stencil clip debug enabled: %s", property);
189 if (!strcmp(property, "hide")) {
190 debugStencilClip = kStencilHide;
191 } else if (!strcmp(property, "highlight")) {
192 debugStencilClip = kStencilShowHighlight;
193 } else if (!strcmp(property, "region")) {
194 debugStencilClip = kStencilShowRegion;
195 }
196 } else {
197 debugStencilClip = kStencilHide;
198 }
199
200 if (property_get(PROPERTY_DISABLE_DRAW_DEFER, property, "false")) {
201 drawDeferDisabled = !strcasecmp(property, "true");
202 INIT_LOGD(" Draw defer %s", drawDeferDisabled ? "disabled" : "enabled");
203 } else {
204 drawDeferDisabled = false;
205 INIT_LOGD(" Draw defer enabled");
206 }
207
208 if (property_get(PROPERTY_DISABLE_DRAW_REORDER, property, "false")) {
209 drawReorderDisabled = !strcasecmp(property, "true");
210 INIT_LOGD(" Draw reorder %s", drawReorderDisabled ? "disabled" : "enabled");
211 } else {
212 drawReorderDisabled = false;
213 INIT_LOGD(" Draw reorder enabled");
214 }
215
216 return (prevDebugLayersUpdates != debugLayersUpdates) ||
217 (prevDebugOverdraw != debugOverdraw) ||
218 (prevDebugStencilClip != debugStencilClip);
219 }
220
terminate()221 void Caches::terminate() {
222 if (!mInitialized) return;
223
224 glDeleteBuffers(1, &meshBuffer);
225 mCurrentBuffer = 0;
226
227 glDeleteBuffers(1, &mMeshIndices);
228 delete[] mRegionMesh;
229 mMeshIndices = 0;
230 mRegionMesh = NULL;
231
232 glDeleteBuffers(1, &mShadowStripsIndices);
233 mShadowStripsIndices = 0;
234
235 fboCache.clear();
236
237 programCache.clear();
238 currentProgram = NULL;
239
240 patchCache.clear();
241
242 clearGarbage();
243
244 mInitialized = false;
245 }
246
247 ///////////////////////////////////////////////////////////////////////////////
248 // Debug
249 ///////////////////////////////////////////////////////////////////////////////
250
getOverdrawColor(uint32_t amount) const251 uint32_t Caches::getOverdrawColor(uint32_t amount) const {
252 static uint32_t sOverdrawColors[2][4] = {
253 { 0x2f0000ff, 0x2f00ff00, 0x3fff0000, 0x7fff0000 },
254 { 0x2f0000ff, 0x4fffff00, 0x5fff8ad8, 0x7fff0000 }
255 };
256 if (amount < 1) amount = 1;
257 if (amount > 4) amount = 4;
258 return sOverdrawColors[mOverdrawDebugColorSet][amount - 1];
259 }
260
dumpMemoryUsage()261 void Caches::dumpMemoryUsage() {
262 String8 stringLog;
263 dumpMemoryUsage(stringLog);
264 ALOGD("%s", stringLog.string());
265 }
266
dumpMemoryUsage(String8 & log)267 void Caches::dumpMemoryUsage(String8 &log) {
268 uint32_t total = 0;
269 log.appendFormat("Current memory usage / total memory usage (bytes):\n");
270 log.appendFormat(" TextureCache %8d / %8d\n",
271 textureCache.getSize(), textureCache.getMaxSize());
272 log.appendFormat(" LayerCache %8d / %8d (numLayers = %zu)\n",
273 layerCache.getSize(), layerCache.getMaxSize(), layerCache.getCount());
274 if (mRenderState) {
275 int memused = 0;
276 for (std::set<Layer*>::iterator it = mRenderState->mActiveLayers.begin();
277 it != mRenderState->mActiveLayers.end(); it++) {
278 const Layer* layer = *it;
279 log.appendFormat(" Layer size %dx%d; isTextureLayer()=%d; texid=%u fbo=%u; refs=%d\n",
280 layer->getWidth(), layer->getHeight(),
281 layer->isTextureLayer(), layer->getTexture(),
282 layer->getFbo(), layer->getStrongCount());
283 memused += layer->getWidth() * layer->getHeight() * 4;
284 }
285 log.appendFormat(" Layers total %8d (numLayers = %zu)\n",
286 memused, mRenderState->mActiveLayers.size());
287 total += memused;
288 }
289 log.appendFormat(" RenderBufferCache %8d / %8d\n",
290 renderBufferCache.getSize(), renderBufferCache.getMaxSize());
291 log.appendFormat(" GradientCache %8d / %8d\n",
292 gradientCache.getSize(), gradientCache.getMaxSize());
293 log.appendFormat(" PathCache %8d / %8d\n",
294 pathCache.getSize(), pathCache.getMaxSize());
295 log.appendFormat(" TessellationCache %8d / %8d\n",
296 tessellationCache.getSize(), tessellationCache.getMaxSize());
297 log.appendFormat(" TextDropShadowCache %8d / %8d\n", dropShadowCache.getSize(),
298 dropShadowCache.getMaxSize());
299 log.appendFormat(" PatchCache %8d / %8d\n",
300 patchCache.getSize(), patchCache.getMaxSize());
301 for (uint32_t i = 0; i < fontRenderer->getFontRendererCount(); i++) {
302 const uint32_t sizeA8 = fontRenderer->getFontRendererSize(i, GL_ALPHA);
303 const uint32_t sizeRGBA = fontRenderer->getFontRendererSize(i, GL_RGBA);
304 log.appendFormat(" FontRenderer %d A8 %8d / %8d\n", i, sizeA8, sizeA8);
305 log.appendFormat(" FontRenderer %d RGBA %8d / %8d\n", i, sizeRGBA, sizeRGBA);
306 log.appendFormat(" FontRenderer %d total %8d / %8d\n", i, sizeA8 + sizeRGBA,
307 sizeA8 + sizeRGBA);
308 }
309 log.appendFormat("Other:\n");
310 log.appendFormat(" FboCache %8d / %8d\n",
311 fboCache.getSize(), fboCache.getMaxSize());
312
313 total += textureCache.getSize();
314 total += renderBufferCache.getSize();
315 total += gradientCache.getSize();
316 total += pathCache.getSize();
317 total += tessellationCache.getSize();
318 total += dropShadowCache.getSize();
319 total += patchCache.getSize();
320 for (uint32_t i = 0; i < fontRenderer->getFontRendererCount(); i++) {
321 total += fontRenderer->getFontRendererSize(i, GL_ALPHA);
322 total += fontRenderer->getFontRendererSize(i, GL_RGBA);
323 }
324
325 log.appendFormat("Total memory usage:\n");
326 log.appendFormat(" %d bytes, %.2f MB\n", total, total / 1024.0f / 1024.0f);
327 }
328
329 ///////////////////////////////////////////////////////////////////////////////
330 // Memory management
331 ///////////////////////////////////////////////////////////////////////////////
332
clearGarbage()333 void Caches::clearGarbage() {
334 textureCache.clearGarbage();
335 pathCache.clearGarbage();
336 patchCache.clearGarbage();
337 }
338
flush(FlushMode mode)339 void Caches::flush(FlushMode mode) {
340 FLUSH_LOGD("Flushing caches (mode %d)", mode);
341
342 // We must stop tasks before clearing caches
343 if (mode > kFlushMode_Layers) {
344 tasks.stop();
345 }
346
347 switch (mode) {
348 case kFlushMode_Full:
349 textureCache.clear();
350 patchCache.clear();
351 dropShadowCache.clear();
352 gradientCache.clear();
353 fontRenderer->clear();
354 fboCache.clear();
355 dither.clear();
356 // fall through
357 case kFlushMode_Moderate:
358 fontRenderer->flush();
359 textureCache.flush();
360 pathCache.clear();
361 tessellationCache.clear();
362 // fall through
363 case kFlushMode_Layers:
364 layerCache.clear();
365 renderBufferCache.clear();
366 break;
367 }
368
369 clearGarbage();
370 glFinish();
371 }
372
373 ///////////////////////////////////////////////////////////////////////////////
374 // VBO
375 ///////////////////////////////////////////////////////////////////////////////
376
bindMeshBuffer()377 bool Caches::bindMeshBuffer() {
378 return bindMeshBuffer(meshBuffer);
379 }
380
bindMeshBuffer(const GLuint buffer)381 bool Caches::bindMeshBuffer(const GLuint buffer) {
382 if (mCurrentBuffer != buffer) {
383 glBindBuffer(GL_ARRAY_BUFFER, buffer);
384 mCurrentBuffer = buffer;
385 return true;
386 }
387 return false;
388 }
389
unbindMeshBuffer()390 bool Caches::unbindMeshBuffer() {
391 if (mCurrentBuffer) {
392 glBindBuffer(GL_ARRAY_BUFFER, 0);
393 mCurrentBuffer = 0;
394 return true;
395 }
396 return false;
397 }
398
bindIndicesBufferInternal(const GLuint buffer)399 bool Caches::bindIndicesBufferInternal(const GLuint buffer) {
400 if (mCurrentIndicesBuffer != buffer) {
401 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
402 mCurrentIndicesBuffer = buffer;
403 return true;
404 }
405 return false;
406 }
407
bindQuadIndicesBuffer()408 bool Caches::bindQuadIndicesBuffer() {
409 if (!mMeshIndices) {
410 uint16_t* regionIndices = new uint16_t[gMaxNumberOfQuads * 6];
411 for (uint32_t i = 0; i < gMaxNumberOfQuads; i++) {
412 uint16_t quad = i * 4;
413 int index = i * 6;
414 regionIndices[index ] = quad; // top-left
415 regionIndices[index + 1] = quad + 1; // top-right
416 regionIndices[index + 2] = quad + 2; // bottom-left
417 regionIndices[index + 3] = quad + 2; // bottom-left
418 regionIndices[index + 4] = quad + 1; // top-right
419 regionIndices[index + 5] = quad + 3; // bottom-right
420 }
421
422 glGenBuffers(1, &mMeshIndices);
423 bool force = bindIndicesBufferInternal(mMeshIndices);
424 glBufferData(GL_ELEMENT_ARRAY_BUFFER, gMaxNumberOfQuads * 6 * sizeof(uint16_t),
425 regionIndices, GL_STATIC_DRAW);
426
427 delete[] regionIndices;
428 return force;
429 }
430
431 return bindIndicesBufferInternal(mMeshIndices);
432 }
433
bindShadowIndicesBuffer()434 bool Caches::bindShadowIndicesBuffer() {
435 if (!mShadowStripsIndices) {
436 uint16_t* shadowIndices = new uint16_t[MAX_SHADOW_INDEX_COUNT];
437 ShadowTessellator::generateShadowIndices(shadowIndices);
438 glGenBuffers(1, &mShadowStripsIndices);
439 bool force = bindIndicesBufferInternal(mShadowStripsIndices);
440 glBufferData(GL_ELEMENT_ARRAY_BUFFER, MAX_SHADOW_INDEX_COUNT * sizeof(uint16_t),
441 shadowIndices, GL_STATIC_DRAW);
442
443 delete[] shadowIndices;
444 return force;
445 }
446
447 return bindIndicesBufferInternal(mShadowStripsIndices);
448 }
449
unbindIndicesBuffer()450 bool Caches::unbindIndicesBuffer() {
451 if (mCurrentIndicesBuffer) {
452 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
453 mCurrentIndicesBuffer = 0;
454 return true;
455 }
456 return false;
457 }
458
459 ///////////////////////////////////////////////////////////////////////////////
460 // PBO
461 ///////////////////////////////////////////////////////////////////////////////
462
bindPixelBuffer(const GLuint buffer)463 bool Caches::bindPixelBuffer(const GLuint buffer) {
464 if (mCurrentPixelBuffer != buffer) {
465 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer);
466 mCurrentPixelBuffer = buffer;
467 return true;
468 }
469 return false;
470 }
471
unbindPixelBuffer()472 bool Caches::unbindPixelBuffer() {
473 if (mCurrentPixelBuffer) {
474 glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
475 mCurrentPixelBuffer = 0;
476 return true;
477 }
478 return false;
479 }
480
481 ///////////////////////////////////////////////////////////////////////////////
482 // Meshes and textures
483 ///////////////////////////////////////////////////////////////////////////////
484
bindPositionVertexPointer(bool force,const GLvoid * vertices,GLsizei stride)485 void Caches::bindPositionVertexPointer(bool force, const GLvoid* vertices, GLsizei stride) {
486 if (force || vertices != mCurrentPositionPointer || stride != mCurrentPositionStride) {
487 GLuint slot = currentProgram->position;
488 glVertexAttribPointer(slot, 2, GL_FLOAT, GL_FALSE, stride, vertices);
489 mCurrentPositionPointer = vertices;
490 mCurrentPositionStride = stride;
491 }
492 }
493
bindTexCoordsVertexPointer(bool force,const GLvoid * vertices,GLsizei stride)494 void Caches::bindTexCoordsVertexPointer(bool force, const GLvoid* vertices, GLsizei stride) {
495 if (force || vertices != mCurrentTexCoordsPointer || stride != mCurrentTexCoordsStride) {
496 GLuint slot = currentProgram->texCoords;
497 glVertexAttribPointer(slot, 2, GL_FLOAT, GL_FALSE, stride, vertices);
498 mCurrentTexCoordsPointer = vertices;
499 mCurrentTexCoordsStride = stride;
500 }
501 }
502
resetVertexPointers()503 void Caches::resetVertexPointers() {
504 mCurrentPositionPointer = this;
505 mCurrentTexCoordsPointer = this;
506 }
507
resetTexCoordsVertexPointer()508 void Caches::resetTexCoordsVertexPointer() {
509 mCurrentTexCoordsPointer = this;
510 }
511
enableTexCoordsVertexArray()512 void Caches::enableTexCoordsVertexArray() {
513 if (!mTexCoordsArrayEnabled) {
514 glEnableVertexAttribArray(Program::kBindingTexCoords);
515 mCurrentTexCoordsPointer = this;
516 mTexCoordsArrayEnabled = true;
517 }
518 }
519
disableTexCoordsVertexArray()520 void Caches::disableTexCoordsVertexArray() {
521 if (mTexCoordsArrayEnabled) {
522 glDisableVertexAttribArray(Program::kBindingTexCoords);
523 mTexCoordsArrayEnabled = false;
524 }
525 }
526
activeTexture(GLuint textureUnit)527 void Caches::activeTexture(GLuint textureUnit) {
528 if (mTextureUnit != textureUnit) {
529 glActiveTexture(gTextureUnits[textureUnit]);
530 mTextureUnit = textureUnit;
531 }
532 }
533
resetActiveTexture()534 void Caches::resetActiveTexture() {
535 mTextureUnit = -1;
536 }
537
bindTexture(GLuint texture)538 void Caches::bindTexture(GLuint texture) {
539 if (mBoundTextures[mTextureUnit] != texture) {
540 glBindTexture(GL_TEXTURE_2D, texture);
541 mBoundTextures[mTextureUnit] = texture;
542 }
543 }
544
bindTexture(GLenum target,GLuint texture)545 void Caches::bindTexture(GLenum target, GLuint texture) {
546 if (target == GL_TEXTURE_2D) {
547 bindTexture(texture);
548 } else {
549 // GLConsumer directly calls glBindTexture() with
550 // target=GL_TEXTURE_EXTERNAL_OES, don't cache this target
551 // since the cached state could be stale
552 glBindTexture(target, texture);
553 }
554 }
555
deleteTexture(GLuint texture)556 void Caches::deleteTexture(GLuint texture) {
557 // When glDeleteTextures() is called on a currently bound texture,
558 // OpenGL ES specifies that the texture is then considered unbound
559 // Consider the following series of calls:
560 //
561 // glGenTextures -> creates texture name 2
562 // glBindTexture(2)
563 // glDeleteTextures(2) -> 2 is now unbound
564 // glGenTextures -> can return 2 again
565 //
566 // If we don't call glBindTexture(2) after the second glGenTextures
567 // call, any texture operation will be performed on the default
568 // texture (name=0)
569
570 unbindTexture(texture);
571
572 glDeleteTextures(1, &texture);
573 }
574
resetBoundTextures()575 void Caches::resetBoundTextures() {
576 memset(mBoundTextures, 0, REQUIRED_TEXTURE_UNITS_COUNT * sizeof(GLuint));
577 }
578
unbindTexture(GLuint texture)579 void Caches::unbindTexture(GLuint texture) {
580 for (int i = 0; i < REQUIRED_TEXTURE_UNITS_COUNT; i++) {
581 if (mBoundTextures[i] == texture) {
582 mBoundTextures[i] = 0;
583 }
584 }
585 }
586
587 ///////////////////////////////////////////////////////////////////////////////
588 // Scissor
589 ///////////////////////////////////////////////////////////////////////////////
590
setScissor(GLint x,GLint y,GLint width,GLint height)591 bool Caches::setScissor(GLint x, GLint y, GLint width, GLint height) {
592 if (scissorEnabled && (x != mScissorX || y != mScissorY ||
593 width != mScissorWidth || height != mScissorHeight)) {
594
595 if (x < 0) {
596 width += x;
597 x = 0;
598 }
599 if (y < 0) {
600 height += y;
601 y = 0;
602 }
603 if (width < 0) {
604 width = 0;
605 }
606 if (height < 0) {
607 height = 0;
608 }
609 glScissor(x, y, width, height);
610
611 mScissorX = x;
612 mScissorY = y;
613 mScissorWidth = width;
614 mScissorHeight = height;
615
616 return true;
617 }
618 return false;
619 }
620
enableScissor()621 bool Caches::enableScissor() {
622 if (!scissorEnabled) {
623 glEnable(GL_SCISSOR_TEST);
624 scissorEnabled = true;
625 resetScissor();
626 return true;
627 }
628 return false;
629 }
630
disableScissor()631 bool Caches::disableScissor() {
632 if (scissorEnabled) {
633 glDisable(GL_SCISSOR_TEST);
634 scissorEnabled = false;
635 return true;
636 }
637 return false;
638 }
639
setScissorEnabled(bool enabled)640 void Caches::setScissorEnabled(bool enabled) {
641 if (scissorEnabled != enabled) {
642 if (enabled) glEnable(GL_SCISSOR_TEST);
643 else glDisable(GL_SCISSOR_TEST);
644 scissorEnabled = enabled;
645 }
646 }
647
resetScissor()648 void Caches::resetScissor() {
649 mScissorX = mScissorY = mScissorWidth = mScissorHeight = 0;
650 }
651
652 ///////////////////////////////////////////////////////////////////////////////
653 // Tiling
654 ///////////////////////////////////////////////////////////////////////////////
655
startTiling(GLuint x,GLuint y,GLuint width,GLuint height,bool discard)656 void Caches::startTiling(GLuint x, GLuint y, GLuint width, GLuint height, bool discard) {
657 if (mExtensions.hasTiledRendering() && !debugOverdraw) {
658 glStartTilingQCOM(x, y, width, height, (discard ? GL_NONE : GL_COLOR_BUFFER_BIT0_QCOM));
659 }
660 }
661
endTiling()662 void Caches::endTiling() {
663 if (mExtensions.hasTiledRendering() && !debugOverdraw) {
664 glEndTilingQCOM(GL_COLOR_BUFFER_BIT0_QCOM);
665 }
666 }
667
hasRegisteredFunctors()668 bool Caches::hasRegisteredFunctors() {
669 return mFunctorsCount > 0;
670 }
671
registerFunctors(uint32_t functorCount)672 void Caches::registerFunctors(uint32_t functorCount) {
673 mFunctorsCount += functorCount;
674 }
675
unregisterFunctors(uint32_t functorCount)676 void Caches::unregisterFunctors(uint32_t functorCount) {
677 if (functorCount > mFunctorsCount) {
678 mFunctorsCount = 0;
679 } else {
680 mFunctorsCount -= functorCount;
681 }
682 }
683
684 ///////////////////////////////////////////////////////////////////////////////
685 // Regions
686 ///////////////////////////////////////////////////////////////////////////////
687
getRegionMesh()688 TextureVertex* Caches::getRegionMesh() {
689 // Create the mesh, 2 triangles and 4 vertices per rectangle in the region
690 if (!mRegionMesh) {
691 mRegionMesh = new TextureVertex[gMaxNumberOfQuads * 4];
692 }
693
694 return mRegionMesh;
695 }
696
697 ///////////////////////////////////////////////////////////////////////////////
698 // Temporary Properties
699 ///////////////////////////////////////////////////////////////////////////////
700
initTempProperties()701 void Caches::initTempProperties() {
702 propertyLightDiameter = -1.0f;
703 propertyLightPosY = -1.0f;
704 propertyLightPosZ = -1.0f;
705 propertyAmbientRatio = -1.0f;
706 propertyAmbientShadowStrength = -1;
707 propertySpotShadowStrength = -1;
708 }
709
setTempProperty(const char * name,const char * value)710 void Caches::setTempProperty(const char* name, const char* value) {
711 ALOGD("setting property %s to %s", name, value);
712 if (!strcmp(name, "ambientRatio")) {
713 propertyAmbientRatio = fmin(fmax(atof(value), 0.0), 10.0);
714 ALOGD("ambientRatio = %.2f", propertyAmbientRatio);
715 return;
716 } else if (!strcmp(name, "lightDiameter")) {
717 propertyLightDiameter = fmin(fmax(atof(value), 0.0), 3000.0);
718 ALOGD("lightDiameter = %.2f", propertyLightDiameter);
719 return;
720 } else if (!strcmp(name, "lightPosY")) {
721 propertyLightPosY = fmin(fmax(atof(value), 0.0), 3000.0);
722 ALOGD("lightPos Y = %.2f", propertyLightPosY);
723 return;
724 } else if (!strcmp(name, "lightPosZ")) {
725 propertyLightPosZ = fmin(fmax(atof(value), 0.0), 3000.0);
726 ALOGD("lightPos Z = %.2f", propertyLightPosZ);
727 return;
728 } else if (!strcmp(name, "ambientShadowStrength")) {
729 propertyAmbientShadowStrength = atoi(value);
730 ALOGD("ambient shadow strength = 0x%x out of 0xff", propertyAmbientShadowStrength);
731 return;
732 } else if (!strcmp(name, "spotShadowStrength")) {
733 propertySpotShadowStrength = atoi(value);
734 ALOGD("spot shadow strength = 0x%x out of 0xff", propertySpotShadowStrength);
735 return;
736 }
737 ALOGD(" failed");
738 }
739
740 }; // namespace uirenderer
741 }; // namespace android
742