Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Remove lookup3 gamma code"

Browse Source
This commit is contained in:
Chris Craik
2015-09-23 17:59:44 +00:00
committed by Android (Google) Code Review
parent f64b00bc1e c08820f587
commit f44b980e95
11 changed files with 60 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
libs/hwui/Caches.cpp
View File

@@ -54,7 +54,6 @@ Caches::Caches(RenderState& renderState)
, mInitialized(false) {
INIT_LOGD("Creating OpenGL renderer caches");
init();
initFont();
initConstraints();
initStaticProperties();
initExtensions();
@@ -78,10 +77,6 @@ bool Caches::init() {
return true;
}
void Caches::initFont() {
fontRenderer = GammaFontRenderer::createRenderer();
}
void Caches::initExtensions() {
if (mExtensions.hasDebugMarker()) {
eventMark = glInsertEventMarkerEXT;
@@ -100,15 +95,9 @@ void Caches::initConstraints() {
}
void Caches::initStaticProperties() {
gpuPixelBuffersEnabled = false;
// OpenGL ES 3.0+ specific features
if (mExtensions.hasPixelBufferObjects()) {
char property[PROPERTY_VALUE_MAX];
if (property_get(PROPERTY_ENABLE_GPU_PIXEL_BUFFERS, property, "true") > 0) {
gpuPixelBuffersEnabled = !strcmp(property, "true");
}
}
gpuPixelBuffersEnabled = mExtensions.hasPixelBufferObjects()
&& property_get_bool(PROPERTY_ENABLE_GPU_PIXEL_BUFFERS, true);
}
void Caches::terminate() {
@@ -203,14 +192,14 @@ void Caches::dumpMemoryUsage(String8 &log) {
dropShadowCache.getMaxSize());
log.appendFormat(" PatchCache %8d / %8d\n",
patchCache.getSize(), patchCache.getMaxSize());
for (uint32_t i = 0; i < fontRenderer->getFontRendererCount(); i++) {
const uint32_t sizeA8 = fontRenderer->getFontRendererSize(i, GL_ALPHA);
const uint32_t sizeRGBA = fontRenderer->getFontRendererSize(i, GL_RGBA);
log.appendFormat(" FontRenderer %d A8 %8d / %8d\n", i, sizeA8, sizeA8);
log.appendFormat(" FontRenderer %d RGBA %8d / %8d\n", i, sizeRGBA, sizeRGBA);
log.appendFormat(" FontRenderer %d total %8d / %8d\n", i, sizeA8 + sizeRGBA,
sizeA8 + sizeRGBA);
}
const uint32_t sizeA8 = fontRenderer.getFontRendererSize(GL_ALPHA);
const uint32_t sizeRGBA = fontRenderer.getFontRendererSize(GL_RGBA);
log.appendFormat(" FontRenderer A8 %8d / %8d\n", sizeA8, sizeA8);
log.appendFormat(" FontRenderer RGBA %8d / %8d\n", sizeRGBA, sizeRGBA);
log.appendFormat(" FontRenderer total %8d / %8d\n", sizeA8 + sizeRGBA,
sizeA8 + sizeRGBA);
log.appendFormat("Other:\n");
log.appendFormat(" FboCache %8d / %8d\n",
fboCache.getSize(), fboCache.getMaxSize());
@@ -222,10 +211,8 @@ void Caches::dumpMemoryUsage(String8 &log) {
total += tessellationCache.getSize();
total += dropShadowCache.getSize();
total += patchCache.getSize();
for (uint32_t i = 0; i < fontRenderer->getFontRendererCount(); i++) {
total += fontRenderer->getFontRendererSize(i, GL_ALPHA);
total += fontRenderer->getFontRendererSize(i, GL_RGBA);
}
total += fontRenderer.getFontRendererSize(GL_ALPHA);
total += fontRenderer.getFontRendererSize(GL_RGBA);
log.appendFormat("Total memory usage:\n");
log.appendFormat(" %d bytes, %.2f MB\n", total, total / 1024.0f / 1024.0f);
@@ -250,12 +237,12 @@ void Caches::flush(FlushMode mode) {
patchCache.clear();
dropShadowCache.clear();
gradientCache.clear();
fontRenderer->clear();
fontRenderer.clear();
fboCache.clear();
dither.clear();
// fall through
case FlushMode::Moderate:
fontRenderer->flush();
fontRenderer.flush();
textureCache.flush();
pathCache.clear();
tessellationCache.clear();

7
libs/hwui/Caches.h
View File

@@ -21,6 +21,7 @@
#include "Dither.h"
#include "Extensions.h"
#include "FboCache.h"
#include "GammaFontRenderer.h"
#include "GradientCache.h"
#include "LayerCache.h"
#include "PatchCache.h"
@@ -53,8 +54,6 @@
namespace android {
namespace uirenderer {
class GammaFontRenderer;
///////////////////////////////////////////////////////////////////////////////
// Caches
///////////////////////////////////////////////////////////////////////////////
@@ -156,7 +155,7 @@ public:
TextDropShadowCache dropShadowCache;
FboCache fboCache;
GammaFontRenderer* fontRenderer;
GammaFontRenderer fontRenderer;
TaskManager tasks;
@@ -178,8 +177,6 @@ public:
TextureState& textureState() { return *mTextureState; }
private:
void initFont();
void initExtensions();
void initConstraints();
void initStaticProperties();

2
libs/hwui/DeferredDisplayList.cpp
View File

@@ -631,7 +631,7 @@ static void replayBatchList(const std::vector<Batch*>& batchList,
void DeferredDisplayList::flush(OpenGLRenderer& renderer, Rect& dirty) {
ATRACE_NAME("flush drawing commands");
Caches::getInstance().fontRenderer->endPrecaching();
Caches::getInstance().fontRenderer.endPrecaching();
if (isEmpty()) return; // nothing to flush
renderer.restoreToCount(1);

4
libs/hwui/DisplayListOp.h
View File

@@ -1246,7 +1246,7 @@ public:
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) override {
FontRenderer& fontRenderer = renderer.getCaches().fontRenderer->getFontRenderer(mPaint);
FontRenderer& fontRenderer = renderer.getCaches().fontRenderer.getFontRenderer();
fontRenderer.precache(mPaint, mText, mCount, SkMatrix::I());
deferInfo.batchId = mPaint->getColor() == SK_ColorBLACK ?
@@ -1311,7 +1311,7 @@ public:
virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
const DeferredDisplayState& state) override {
FontRenderer& fontRenderer = renderer.getCaches().fontRenderer->getFontRenderer(mPaint);
FontRenderer& fontRenderer = renderer.getCaches().fontRenderer.getFontRenderer();
SkMatrix transform;
renderer.findBestFontTransform(state.mMatrix, &transform);
if (mPrecacheTransform != transform) {

32
libs/hwui/FontRenderer.cpp
View File

@@ -75,8 +75,8 @@ void TextDrawFunctor::draw(CacheTexture& texture, bool linearFiltering) {
static bool sLogFontRendererCreate = true;
FontRenderer::FontRenderer()
: mGammaTable(nullptr)
FontRenderer::FontRenderer(const uint8_t* gammaTable)
: mGammaTable(gammaTable)
, mCurrentFont(nullptr)
, mActiveFonts(LruCache<Font::FontDescription, Font*>::kUnlimitedCapacity)
, mCurrentCacheTexture(nullptr)
@@ -92,27 +92,15 @@ FontRenderer::FontRenderer()
INIT_LOGD("Creating FontRenderer");
}
mSmallCacheWidth = DEFAULT_TEXT_SMALL_CACHE_WIDTH;
mSmallCacheHeight = DEFAULT_TEXT_SMALL_CACHE_HEIGHT;
mLargeCacheWidth = DEFAULT_TEXT_LARGE_CACHE_WIDTH;
mLargeCacheHeight = DEFAULT_TEXT_LARGE_CACHE_HEIGHT;
mSmallCacheWidth = property_get_int32(PROPERTY_TEXT_SMALL_CACHE_WIDTH,
DEFAULT_TEXT_SMALL_CACHE_WIDTH);
mSmallCacheHeight = property_get_int32(PROPERTY_TEXT_SMALL_CACHE_HEIGHT,
DEFAULT_TEXT_SMALL_CACHE_HEIGHT);
char property[PROPERTY_VALUE_MAX];
if (property_get(PROPERTY_TEXT_SMALL_CACHE_WIDTH, property, nullptr) > 0) {
mSmallCacheWidth = atoi(property);
}
if (property_get(PROPERTY_TEXT_SMALL_CACHE_HEIGHT, property, nullptr) > 0) {
mSmallCacheHeight = atoi(property);
}
if (property_get(PROPERTY_TEXT_LARGE_CACHE_WIDTH, property, nullptr) > 0) {
mLargeCacheWidth = atoi(property);
}
if (property_get(PROPERTY_TEXT_LARGE_CACHE_HEIGHT, property, nullptr) > 0) {
mLargeCacheHeight = atoi(property);
}
mLargeCacheWidth = property_get_int32(PROPERTY_TEXT_LARGE_CACHE_WIDTH,
DEFAULT_TEXT_LARGE_CACHE_WIDTH);
mLargeCacheHeight = property_get_int32(PROPERTY_TEXT_LARGE_CACHE_HEIGHT,
DEFAULT_TEXT_LARGE_CACHE_HEIGHT);
uint32_t maxTextureSize = (uint32_t) Caches::getInstance().maxTextureSize;

6
libs/hwui/FontRenderer.h
View File

@@ -72,16 +72,12 @@ public:
class FontRenderer {
public:
FontRenderer();
FontRenderer(const uint8_t* gammaTable);
~FontRenderer();
void flushLargeCaches(std::vector<CacheTexture*>& cacheTextures);
void flushLargeCaches();
void setGammaTable(const uint8_t* gammaTable) {
mGammaTable = gammaTable;
}
void setFont(const SkPaint* paint, const SkMatrix& matrix);
void precache(const SkPaint* paint, const char* text, int numGlyphs, const SkMatrix& matrix);

165
libs/hwui/GammaFontRenderer.cpp
View File

@@ -21,183 +21,22 @@
namespace android {
namespace uirenderer {
///////////////////////////////////////////////////////////////////////////////
// Utils
///////////////////////////////////////////////////////////////////////////////
static int luminance(const SkPaint* paint) {
uint32_t c = paint->getColor();
const int r = (c >> 16) & 0xFF;
const int g = (c >> 8) & 0xFF;
const int b = (c ) & 0xFF;
return (r * 2 + g * 5 + b) >> 3;
}
///////////////////////////////////////////////////////////////////////////////
// Base class GammaFontRenderer
///////////////////////////////////////////////////////////////////////////////
GammaFontRenderer* GammaFontRenderer::createRenderer() {
// Choose the best renderer
char property[PROPERTY_VALUE_MAX];
if (property_get(PROPERTY_TEXT_GAMMA_METHOD, property, DEFAULT_TEXT_GAMMA_METHOD) > 0) {
if (!strcasecmp(property, "lookup")) {
return new LookupGammaFontRenderer();
}
}
return new Lookup3GammaFontRenderer();
}
GammaFontRenderer::GammaFontRenderer() {
// Get the renderer properties
char property[PROPERTY_VALUE_MAX];
// Get the gamma
mGamma = DEFAULT_TEXT_GAMMA;
if (property_get(PROPERTY_TEXT_GAMMA, property, nullptr) > 0) {
INIT_LOGD(" Setting text gamma to %s", property);
mGamma = atof(property);
} else {
INIT_LOGD(" Using default text gamma of %.2f", DEFAULT_TEXT_GAMMA);
}
// Get the black gamma threshold
mBlackThreshold = DEFAULT_TEXT_BLACK_GAMMA_THRESHOLD;
if (property_get(PROPERTY_TEXT_BLACK_GAMMA_THRESHOLD, property, nullptr) > 0) {
INIT_LOGD(" Setting text black gamma threshold to %s", property);
mBlackThreshold = atoi(property);
} else {
INIT_LOGD(" Using default text black gamma threshold of %d",
DEFAULT_TEXT_BLACK_GAMMA_THRESHOLD);
}
// Get the white gamma threshold
mWhiteThreshold = DEFAULT_TEXT_WHITE_GAMMA_THRESHOLD;
if (property_get(PROPERTY_TEXT_WHITE_GAMMA_THRESHOLD, property, nullptr) > 0) {
INIT_LOGD(" Setting text white gamma threshold to %s", property);
mWhiteThreshold = atoi(property);
} else {
INIT_LOGD(" Using default white black gamma threshold of %d",
DEFAULT_TEXT_WHITE_GAMMA_THRESHOLD);
}
}
GammaFontRenderer::~GammaFontRenderer() {
}
///////////////////////////////////////////////////////////////////////////////
// Lookup-based renderer
///////////////////////////////////////////////////////////////////////////////
LookupGammaFontRenderer::LookupGammaFontRenderer()
: GammaFontRenderer() {
INIT_LOGD("Creating lookup gamma font renderer");
// Compute the gamma tables
const float gamma = 1.0f / mGamma;
const float gamma = 1.0f / Properties::textGamma;
for (uint32_t i = 0; i <= 255; i++) {
mGammaTable[i] = uint8_t((float)::floor(pow(i / 255.0f, gamma) * 255.0f + 0.5f));
}
mRenderer = nullptr;
}
void LookupGammaFontRenderer::endPrecaching() {
void GammaFontRenderer::endPrecaching() {
if (mRenderer) {
mRenderer->endPrecaching();
}
}
///////////////////////////////////////////////////////////////////////////////
// Lookup-based renderer, using 3 different correction tables
///////////////////////////////////////////////////////////////////////////////
Lookup3GammaFontRenderer::Lookup3GammaFontRenderer()
: GammaFontRenderer() {
INIT_LOGD("Creating lookup3 gamma font renderer");
// Compute the gamma tables
const float blackGamma = mGamma;
const float whiteGamma = 1.0f / mGamma;
for (uint32_t i = 0; i <= 255; i++) {
const float v = i / 255.0f;
const float black = pow(v, blackGamma);
const float white = pow(v, whiteGamma);
mGammaTable[i] = i;
mGammaTable[256 + i] = uint8_t((float)::floor(black * 255.0f + 0.5f));
mGammaTable[512 + i] = uint8_t((float)::floor(white * 255.0f + 0.5f));
}
memset(mRenderers, 0, sizeof(FontRenderer*) * kGammaCount);
memset(mRenderersUsageCount, 0, sizeof(uint32_t) * kGammaCount);
}
void Lookup3GammaFontRenderer::endPrecaching() {
for (int i = 0; i < kGammaCount; i++) {
if (mRenderers[i]) {
mRenderers[i]->endPrecaching();
}
}
}
void Lookup3GammaFontRenderer::clear() {
for (int i = 0; i < kGammaCount; i++) {
mRenderers[i].release();
}
}
void Lookup3GammaFontRenderer::flush() {
int count = 0;
int min = -1;
uint32_t minCount = UINT_MAX;
for (int i = 0; i < kGammaCount; i++) {
if (mRenderers[i]) {
count++;
if (mRenderersUsageCount[i] < minCount) {
minCount = mRenderersUsageCount[i];
min = i;
}
}
}
if (count <= 1 || min < 0) return;
mRenderers[min].release();
// Also eliminate the caches for large glyphs, as they consume significant memory
for (int i = 0; i < kGammaCount; ++i) {
if (mRenderers[i]) {
mRenderers[i]->flushLargeCaches();
}
}
}
FontRenderer* Lookup3GammaFontRenderer::getRenderer(Gamma gamma) {
if (!mRenderers[gamma]) {
mRenderers[gamma].reset(new FontRenderer());
mRenderers[gamma]->setGammaTable(&mGammaTable[gamma * 256]);
}
mRenderersUsageCount[gamma]++;
return mRenderers[gamma].get();
}
FontRenderer& Lookup3GammaFontRenderer::getFontRenderer(const SkPaint* paint) {
if (paint->getShader() == nullptr) {
const int l = luminance(paint);
if (l <= mBlackThreshold) {
return *getRenderer(kGammaBlack);
} else if (l >= mWhiteThreshold) {
return *getRenderer(kGammaWhite);
}
}
return *getRenderer(kGammaDefault);
}
}; // namespace uirenderer
}; // namespace android

98
libs/hwui/GammaFontRenderer.h
View File

@@ -17,122 +17,44 @@
#ifndef ANDROID_HWUI_GAMMA_FONT_RENDERER_H
#define ANDROID_HWUI_GAMMA_FONT_RENDERER_H
#include <SkPaint.h>
#include "FontRenderer.h"
#include "Program.h"
#include <SkPaint.h>
namespace android {
namespace uirenderer {
class GammaFontRenderer {
public:
virtual ~GammaFontRenderer();
virtual void clear() = 0;
virtual void flush() = 0;
virtual FontRenderer& getFontRenderer(const SkPaint* paint) = 0;
virtual uint32_t getFontRendererCount() const = 0;
virtual uint32_t getFontRendererSize(uint32_t fontRenderer, GLenum format) const = 0;
virtual void endPrecaching() = 0;
static GammaFontRenderer* createRenderer();
protected:
GammaFontRenderer();
int mBlackThreshold;
int mWhiteThreshold;
float mGamma;
};
class LookupGammaFontRenderer: public GammaFontRenderer {
public:
~LookupGammaFontRenderer() {
delete mRenderer;
void clear() {
mRenderer.release();
}
void clear() override {
delete mRenderer;
mRenderer = nullptr;
}
void flush() override {
void flush() {
if (mRenderer) {
mRenderer->flushLargeCaches();
}
}
FontRenderer& getFontRenderer(const SkPaint* paint) override {
FontRenderer& getFontRenderer() {
if (!mRenderer) {
mRenderer = new FontRenderer;
mRenderer->setGammaTable(&mGammaTable[0]);
mRenderer.reset(new FontRenderer(&mGammaTable[0]));
}
return *mRenderer;
}
uint32_t getFontRendererCount() const override {
return 1;
}
uint32_t getFontRendererSize(uint32_t fontRenderer, GLenum format) const override {
uint32_t getFontRendererSize(GLenum format) const {
return mRenderer ? mRenderer->getCacheSize(format) : 0;
}
void endPrecaching() override;
void endPrecaching();
private:
LookupGammaFontRenderer();
FontRenderer* mRenderer;
std::unique_ptr<FontRenderer> mRenderer;
uint8_t mGammaTable[256];
friend class GammaFontRenderer;
};
class Lookup3GammaFontRenderer: public GammaFontRenderer {
public:
void clear() override;
void flush() override;
FontRenderer& getFontRenderer(const SkPaint* paint) override;
uint32_t getFontRendererCount() const override {
return kGammaCount;
}
uint32_t getFontRendererSize(uint32_t fontRenderer, GLenum format) const override {
if (fontRenderer >= kGammaCount) return 0;
if (!mRenderers[fontRenderer]) return 0;
return mRenderers[fontRenderer]->getCacheSize(format);
}
void endPrecaching() override;
private:
Lookup3GammaFontRenderer();
enum Gamma {
kGammaDefault = 0,
kGammaBlack = 1,
kGammaWhite = 2,
kGammaCount = 3
};
FontRenderer* getRenderer(Gamma gamma);
uint32_t mRenderersUsageCount[kGammaCount];
std::unique_ptr<FontRenderer> mRenderers[kGammaCount];
uint8_t mGammaTable[256 * kGammaCount];
friend class GammaFontRenderer;
};
}; // namespace uirenderer

6
libs/hwui/OpenGLRenderer.cpp
View File

@@ -2014,7 +2014,7 @@ void OpenGLRenderer::drawPosText(const char* text, int bytesCount, int count,
y = floorf(y + currentTransform()->getTranslateY() + 0.5f);
}
FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer();
fontRenderer.setFont(paint, SkMatrix::I());
int alpha;
@@ -2166,7 +2166,7 @@ void OpenGLRenderer::drawText(const char* text, int bytesCount, int count, float
SkXfermode::Mode mode;
getAlphaAndMode(paint, &alpha, &mode);
FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer();
if (CC_UNLIKELY(hasTextShadow(paint))) {
fontRenderer.setFont(paint, SkMatrix::I());
@@ -2234,7 +2234,7 @@ void OpenGLRenderer::drawTextOnPath(const char* text, int bytesCount, int count,
// TODO: avoid scissor by calculating maximum bounds using path bounds + font metrics
mRenderState.scissor().setEnabled(true);
FontRenderer& fontRenderer = mCaches.fontRenderer->getFontRenderer(paint);
FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer();
fontRenderer.setFont(paint, SkMatrix::I());
fontRenderer.setTextureFiltering(true);

13
libs/hwui/Properties.cpp
View File

@@ -33,6 +33,8 @@ bool Properties::swapBuffersWithDamage = true;
bool Properties::useBufferAge = true;
bool Properties::enablePartialUpdates = true;
float Properties::textGamma = DEFAULT_TEXT_GAMMA;
DebugLevel Properties::debugLevel = kDebugDisabled;
OverdrawColorSet Properties::overdrawColorSet = OverdrawColorSet::Default;
StencilClipDebug Properties::debugStencilClip = StencilClipDebug::Hide;
@@ -47,6 +49,15 @@ int Properties::overrideSpotShadowStrength = -1;
ProfileType Properties::sProfileType = ProfileType::None;
bool Properties::sDisableProfileBars = false;
static float property_get_float(const char* key, float defaultValue) {
char buf[PROPERTY_VALUE_MAX] = {'\0',};
if (property_get(PROPERTY_PROFILE, buf, "") > 0) {
return atof(buf);
}
return defaultValue;
}
bool Properties::load() {
char property[PROPERTY_VALUE_MAX];
bool prevDebugLayersUpdates = debugLayersUpdates;
@@ -110,6 +121,8 @@ bool Properties::load() {
useBufferAge = property_get_bool(PROPERTY_USE_BUFFER_AGE, true);
enablePartialUpdates = property_get_bool(PROPERTY_ENABLE_PARTIAL_UPDATES, true);
textGamma = property_get_float(PROPERTY_TEXT_GAMMA, DEFAULT_TEXT_GAMMA);
return (prevDebugLayersUpdates != debugLayersUpdates)
|| (prevDebugOverdraw != debugOverdraw)
|| (prevDebugStencilClip != debugStencilClip);

26
libs/hwui/Properties.h
View File

@@ -208,30 +208,8 @@ enum DebugLevel {
#define PROPERTY_TEXT_LARGE_CACHE_WIDTH "ro.hwui.text_large_cache_width"
#define PROPERTY_TEXT_LARGE_CACHE_HEIGHT "ro.hwui.text_large_cache_height"
// Indicates whether gamma correction should be applied in the shaders
// or in lookup tables. Accepted values:
//
// - "lookup3", correction based on lookup tables. Gamma correction
// is different for black and white text (see thresholds below)
//
// - "lookup", correction based on a single lookup table
//
// - "shader3", correction applied by a GLSL shader. Gamma correction
// is different for black and white text (see thresholds below)
//
// - "shader", correction applied by a GLSL shader
//
// See PROPERTY_TEXT_GAMMA, PROPERTY_TEXT_BLACK_GAMMA_THRESHOLD and
// PROPERTY_TEXT_WHITE_GAMMA_THRESHOLD for more control.
#define PROPERTY_TEXT_GAMMA_METHOD "hwui.text_gamma_correction"
#define DEFAULT_TEXT_GAMMA_METHOD "lookup"
// Gamma (>= 1.0, <= 10.0)
#define PROPERTY_TEXT_GAMMA "hwui.text_gamma"
// Luminance threshold below which black gamma correction is applied. Range: [0..255]
#define PROPERTY_TEXT_BLACK_GAMMA_THRESHOLD "hwui.text_gamma.black_threshold"
// Lumincance threshold above which white gamma correction is applied. Range: [0..255]
#define PROPERTY_TEXT_WHITE_GAMMA_THRESHOLD "hwui.text_gamma.white_threshold"
///////////////////////////////////////////////////////////////////////////////
// Default property values
@@ -250,8 +228,6 @@ enum DebugLevel {
#define DEFAULT_TEXTURE_CACHE_FLUSH_RATE 0.6f
#define DEFAULT_TEXT_GAMMA 1.4f
#define DEFAULT_TEXT_BLACK_GAMMA_THRESHOLD 64
#define DEFAULT_TEXT_WHITE_GAMMA_THRESHOLD 192
///////////////////////////////////////////////////////////////////////////////
// Misc
@@ -300,6 +276,8 @@ public:
static bool useBufferAge;
static bool enablePartialUpdates;
static float textGamma;
static DebugLevel debugLevel;
static OverdrawColorSet overdrawColorSet;
static StencilClipDebug debugStencilClip;