MGislv/GLideN64
1
0
Fork 0
mirror of https://github.com/blawar/GLideN64.git synced 2024-07-02 09:03:37 +00:00
Code Issues Projects Releases Wiki Activity

Move gamma correction to post processor.

Browse Source
This commit is contained in:
gonetz 2015-12-23 16:22:30 +06:00 committed by Sergey Lipskiy
parent 330603e2b6
commit a9d1df5694
11 changed files with 163 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/Config.cpp
View File

@ -36,8 +36,6 @@ void Config::resetToDefaults()
generalEmulation.enableCustomSettings = 1;
generalEmulation.enableShadersStorage = 1;
generalEmulation.hacks = 0;
generalEmulation.forceGammaCorrection = 0;
generalEmulation.gammaCorrectionLevel = 2.0f;
#ifdef ANDROID
generalEmulation.forcePolygonOffset = 0;
generalEmulation.polygonOffsetFactor = 0.0f;
@ -95,4 +93,7 @@ void Config::resetToDefaults()
bloomFilter.blendMode = 0;
bloomFilter.blurAmount = 10;
bloomFilter.blurStrength = 20;
gammaCorrection.force = 0;
gammaCorrection.level = 2.0f;
}

10
src/Config.h
View File

@ -9,7 +9,8 @@
#define CONFIG_VERSION_THREE 3U
#define CONFIG_VERSION_FOUR 4U // Remove ValidityCheckMethod setting
#define CONFIG_VERSION_FIVE 5U // Add shader storage option
#define CONFIG_VERSION_CURRENT CONFIG_VERSION_FIVE
#define CONFIG_VERSION_SIX 6U // Change gamma correction options
#define CONFIG_VERSION_CURRENT CONFIG_VERSION_SIX
#define BILINEAR_3POINT 0
#define BILINEAR_STANDARD 1
@ -48,8 +49,6 @@ struct Config
u32 enableCustomSettings;
u32 enableShadersStorage;
u32 hacks;
u32 forceGammaCorrection;
f32 gammaCorrectionLevel;
#ifdef ANDROID
u32 forcePolygonOffset;
f32 polygonOffsetFactor;
@ -123,6 +122,11 @@ struct Config
u32 blurStrength;
} bloomFilter;
struct {
u32 force;
f32 level;
} gammaCorrection;
void resetToDefaults();
};

2
src/FrameBuffer.cpp
View File

@ -739,6 +739,7 @@ void FrameBufferList::renderBuffer(u32 _address)
#endif // GLESX
render.updateScissor(pBuffer);
PostProcessor::get().doGammaCorrection(pBuffer);
PostProcessor::get().doBlur(pBuffer);
// glDisable(GL_SCISSOR_TEST) does not affect glBlitFramebuffer, at least on AMD
glScissor(0, 0, ogl.getScreenWidth(), ogl.getScreenHeight() + ogl.getHeightOffset());
@ -804,6 +805,7 @@ void FrameBufferList::renderBuffer(u32 _address)
OGLVideo & ogl = video();
ogl.getRender().updateScissor(pBuffer);
PostProcessor::get().doGammaCorrection(pBuffer);
PostProcessor::get().doBlur(pBuffer);
ogl.getRender().dropRenderState();
gSP.changed = gDP.changed = 0;

13
src/GLES2/GLSLCombiner_gles2.cpp
View File

@ -201,8 +201,6 @@ ShaderCombiner::ShaderCombiner(Combiner & _color, Combiner & _alpha, const gDPCo
strFragmentShader.append(
" if (uFogUsage == 257) \n"
" fragColor.rgb = mix(fragColor.rgb, uFogColor.rgb, vFogFragCoord); \n"
" if (uGammaCorrectionEnabled != 0) \n"
" fragColor.rgb = pow(fragColor.rgb, vec3(1.0 / uGammaCorrectionLevel)); \n"
" gl_FragColor = fragColor; \n"
);
@ -262,8 +260,6 @@ void ShaderCombiner::_locateUniforms() {
LocateUniform(uFogMode);
LocateUniform(uFogUsage);
LocateUniform(uAlphaCompareMode);
LocateUniform(uGammaCorrectionEnabled);
LocateUniform(uGammaCorrectionLevel);
LocateUniform(uEnableAlphaTest);
LocateUniform(uEnableDepth);
LocateUniform(uEnableDepthCompare)
@ -310,7 +306,6 @@ void ShaderCombiner::update(bool _bForce) {
updateRenderState(true);
}
updateGammaCorrection(_bForce);
updateFogMode(_bForce);
updateDitherMode(_bForce);
updateLOD(_bForce);
@ -324,14 +319,6 @@ void ShaderCombiner::updateRenderState(bool _bForce)
m_uniforms.uRenderState.set(video().getRender().getRenderState(), _bForce);
}
void ShaderCombiner::updateGammaCorrection(bool _bForce)
{
m_uniforms.uGammaCorrectionEnabled.set(((*REG.VI_STATUS & 8)|config.generalEmulation.forceGammaCorrection), _bForce);
f32 gammaLevel = (config.generalEmulation.forceGammaCorrection != 0) ? config.generalEmulation.gammaCorrectionLevel : 2.0f;
m_uniforms.uGammaCorrectionLevel.set(gammaLevel, _bForce);
}
void ShaderCombiner::updateFogMode(bool _bForce)
{
const u32 blender = (gDP.otherMode.l >> 16);

4
src/GLES2/Shaders_gles2.h
View File

@ -161,8 +161,6 @@ SHADER_VERSION
"uniform lowp float uK5; \n"
"uniform mediump vec2 uScreenScale; \n"
"uniform lowp int uAlphaCompareMode; \n"
"uniform lowp int uGammaCorrectionEnabled; \n"
"uniform lowp float uGammaCorrectionLevel; \n"
"uniform lowp int uFogUsage; \n"
"uniform lowp ivec2 uFbMonochrome; \n"
"uniform lowp ivec2 uFbFixedAlpha;\n"
@ -201,8 +199,6 @@ SHADER_VERSION
"uniform lowp float uK5; \n"
"uniform mediump vec2 uScreenScale; \n"
"uniform lowp int uAlphaCompareMode; \n"
"uniform lowp int uGammaCorrectionEnabled; \n"
"uniform lowp float uGammaCorrectionLevel; \n"
"uniform lowp int uFogUsage; \n"
"uniform lowp int uSpecialBlendMode;\n"
"uniform lowp int uEnableAlphaTest; \n"

5
src/GLSLCombiner.h
View File

@ -21,7 +21,6 @@ public:
void updateAlphaTestInfo(bool _bForce = false);
void updateTextureInfo(bool _bForce = false);
void updateRenderState(bool _bForce = false);
void updateGammaCorrection(bool _bForce = false);
u64 getMux() const {return m_combine.mux;}
@ -97,9 +96,9 @@ private:
uEnableDepth, uEnableDepthCompare, uEnableDepthUpdate,
uDepthMode, uDepthSource, uRenderState, uSpecialBlendMode,
uMaxTile, uTextureDetail, uTexturePersp, uTextureFilterMode, uMSAASamples,
uAlphaCompareMode, uAlphaDitherMode, uColorDitherMode, uGammaCorrectionEnabled;
uAlphaCompareMode, uAlphaDitherMode, uColorDitherMode;
fUniform uFogAlpha, uMinLod, uDeltaZ, uAlphaTestValue, uMSAAScale, uGammaCorrectionLevel;
fUniform uFogAlpha, uMinLod, uDeltaZ, uAlphaTestValue, uMSAAScale;
fv2Uniform uScreenScale, uDepthScale, uFogScale;

13
src/OGL3X/GLSLCombiner_ogl3x.cpp
View File

@ -359,8 +359,6 @@ ShaderCombiner::ShaderCombiner(Combiner & _color, Combiner & _alpha, const gDPCo
strFragmentShader.append(
" if (uFogUsage == 257) \n"
" fragColor.rgb = mix(fragColor.rgb, uFogColor.rgb, vFogFragCoord); \n"
" if (uGammaCorrectionEnabled != 0) \n"
" fragColor.rgb = pow(fragColor.rgb, vec3(1.0 / uGammaCorrectionLevel)); \n"
);
strFragmentShader.append(fragment_shader_end);
@ -454,8 +452,6 @@ void ShaderCombiner::_locateUniforms() {
LocateUniform(uAlphaCompareMode);
LocateUniform(uAlphaDitherMode);
LocateUniform(uColorDitherMode);
LocateUniform(uGammaCorrectionEnabled);
LocateUniform(uGammaCorrectionLevel);
LocateUniform(uEnableLod);
LocateUniform(uEnableAlphaTest);
LocateUniform(uEnableDepth);
@ -522,7 +518,6 @@ void ShaderCombiner::update(bool _bForce) {
updateRenderState(true);
}
updateGammaCorrection(_bForce);
updateFogMode(_bForce);
updateDitherMode(_bForce);
updateLOD(_bForce);
@ -536,14 +531,6 @@ void ShaderCombiner::updateRenderState(bool _bForce)
m_uniforms.uRenderState.set(video().getRender().getRenderState(), _bForce);
}
void ShaderCombiner::updateGammaCorrection(bool _bForce)
{
m_uniforms.uGammaCorrectionEnabled.set(((*REG.VI_STATUS & 8)|config.generalEmulation.forceGammaCorrection), _bForce);
f32 gammaLevel = (config.generalEmulation.forceGammaCorrection != 0) ? config.generalEmulation.gammaCorrectionLevel : 2.0f;
m_uniforms.uGammaCorrectionLevel.set(gammaLevel, _bForce);
}
void ShaderCombiner::updateFogMode(bool _bForce)
{
const u32 blender = (gDP.otherMode.l >> 16);

4
src/OGL3X/Shaders_ogl3x.h
View File

@ -168,8 +168,6 @@ MAIN_SHADER_VERSION
"uniform lowp int uAlphaCompareMode; \n"
"uniform lowp int uAlphaDitherMode; \n"
"uniform lowp int uColorDitherMode; \n"
"uniform lowp int uGammaCorrectionEnabled; \n"
"uniform lowp float uGammaCorrectionLevel; \n"
"uniform lowp int uFogUsage; \n"
"uniform lowp ivec2 uFbMonochrome; \n"
"uniform lowp ivec2 uFbFixedAlpha;\n"
@ -206,8 +204,6 @@ MAIN_SHADER_VERSION
"uniform lowp int uAlphaCompareMode; \n"
"uniform lowp int uAlphaDitherMode; \n"
"uniform lowp int uColorDitherMode; \n"
"uniform lowp int uGammaCorrectionEnabled; \n"
"uniform lowp float uGammaCorrectionLevel; \n"
"uniform lowp int uFogUsage; \n"
"uniform lowp int uSpecialBlendMode;\n"
"uniform lowp int uEnableAlphaTest; \n"

163
src/PostProcessor.cpp
View File

@ -236,16 +236,39 @@ FRAGMENT_SHADER_END
"} \n"
;
static const char* gammaCorrectionShader =
SHADER_VERSION
"#if (__VERSION__ > 120) \n"
"# define IN in \n"
"# define OUT out \n"
"# define texture2D texture \n"
"#else \n"
"# define IN varying \n"
"# define OUT \n"
"#endif // __VERSION __ \n"
"IN mediump vec2 vTexCoord; \n"
"uniform sampler2D Sample0; \n"
"uniform lowp float uGammaCorrectionLevel; \n"
"OUT lowp vec4 fragColor; \n"
" \n"
"void main() \n"
"{ \n"
" fragColor = texture2D(Sample0, vTexCoord); \n"
" fragColor.rgb = pow(fragColor.rgb, vec3(1.0 / uGammaCorrectionLevel)); \n"
FRAGMENT_SHADER_END
"} \n"
;
static
GLuint _createShaderProgram(const char * _strVertex, const char * _strFragment)
{
GLuint vertex_shader_object = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader_object, 1, &_strVertex, NULL);
glShaderSource(vertex_shader_object, 1, &_strVertex, nullptr);
glCompileShader(vertex_shader_object);
assert(checkShaderCompileStatus(vertex_shader_object));
GLuint fragment_shader_object = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader_object, 1, &_strFragment, NULL);
glShaderSource(fragment_shader_object, 1, &_strFragment, nullptr);
glCompileShader(fragment_shader_object);
assert(checkShaderCompileStatus(fragment_shader_object));
@ -279,7 +302,7 @@ CachedTexture * _createTexture()
textureCache().addFrameBufferTextureSize(pTexture->textureBytes);
glBindTexture(GL_TEXTURE_2D, pTexture->glName);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pTexture->realWidth, pTexture->realHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pTexture->realWidth, pTexture->realHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
@ -297,11 +320,39 @@ GLuint _createFBO(CachedTexture * _pTexture)
return FBO;
}
void PostProcessor::_initBlur()
void PostProcessor::_initCommon()
{
m_pTextureOriginal = _createTexture();
m_FBO_original = _createFBO(m_pTextureOriginal);
#ifdef GLES2
m_copyProgram = _createShaderProgram(vertexShader, copyShader);
glUseProgram(m_copyProgram);
int loc = glGetUniformLocation(m_copyProgram, "Sample0");
assert(loc >= 0);
glUniform1i(loc, 0);
glUseProgram(0);
#endif
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
}
void PostProcessor::_initGammaCorrection()
{
m_gammaCorrectionProgram = _createShaderProgram(vertexShader, gammaCorrectionShader);
glUseProgram(m_gammaCorrectionProgram);
int loc = glGetUniformLocation(m_gammaCorrectionProgram, "Sample0");
assert(loc >= 0);
glUniform1i(loc, 0);
loc = glGetUniformLocation(m_gammaCorrectionProgram, "uGammaCorrectionLevel");
assert(loc >= 0);
const f32 gammaLevel = (config.gammaCorrection.force != 0) ? config.gammaCorrection.level : 2.0f;
glUniform1f(loc, gammaLevel);
glUseProgram(0);
}
void PostProcessor::_initBlur()
{
m_extractBloomProgram = _createShaderProgram(vertexShader, extractBloomShader);
glUseProgram(m_extractBloomProgram);
int loc = glGetUniformLocation(m_extractBloomProgram, "Sample0");
@ -311,14 +362,6 @@ void PostProcessor::_initBlur()
assert(loc >= 0);
glUniform1i(loc, config.bloomFilter.thresholdLevel);
#ifdef GLES2
m_copyProgram = _createShaderProgram(vertexShader, copyShader);
glUseProgram(m_copyProgram);
loc = glGetUniformLocation(m_copyProgram, "Sample0");
assert(loc >= 0);
glUniform1i(loc, 0);
#endif
m_seperableBlurProgram = _createShaderProgram(vertexShader, seperableBlurShader);
glUseProgram(m_seperableBlurProgram);
loc = glGetUniformLocation(m_seperableBlurProgram, "Sample0");
@ -359,20 +402,39 @@ void PostProcessor::_initBlur()
m_FBO_blur = _createFBO(m_pTextureBlur);
glUseProgram(0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
}
void PostProcessor::init()
{
_initCommon();
_initGammaCorrection();
if (config.bloomFilter.enable != 0)
_initBlur();
}
void PostProcessor::_destroyBlur()
void PostProcessor::_destroyCommon()
{
if (m_copyProgram != 0)
glDeleteProgram(m_copyProgram);
m_copyProgram = 0;
if (m_FBO_original != 0)
glDeleteFramebuffers(1, &m_FBO_original);
m_FBO_original = 0;
if (m_pTextureOriginal != nullptr)
textureCache().removeFrameBufferTexture(m_pTextureOriginal);
}
void PostProcessor::_destroyGammaCorrection()
{
if (m_gammaCorrectionProgram != 0)
glDeleteProgram(m_gammaCorrectionProgram);
m_gammaCorrectionProgram = 0;
}
void PostProcessor::_destroyBlur()
{
if (m_extractBloomProgram != 0)
glDeleteProgram(m_extractBloomProgram);
m_extractBloomProgram = 0;
@ -386,9 +448,6 @@ void PostProcessor::_destroyBlur()
glDeleteProgram(m_bloomProgram);
m_bloomProgram = 0;
if (m_FBO_original != 0)
glDeleteFramebuffers(1, &m_FBO_original);
m_FBO_original = 0;
if (m_FBO_glowMap != 0)
glDeleteFramebuffers(1, &m_FBO_glowMap);
m_FBO_glowMap = 0;
@ -396,21 +455,21 @@ void PostProcessor::_destroyBlur()
glDeleteFramebuffers(1, &m_FBO_blur);
m_FBO_blur = 0;
if (m_pTextureOriginal != NULL)
textureCache().removeFrameBufferTexture(m_pTextureOriginal);
m_pTextureOriginal = NULL;
if (m_pTextureGlowMap != NULL)
m_pTextureOriginal = nullptr;
if (m_pTextureGlowMap != nullptr)
textureCache().removeFrameBufferTexture(m_pTextureGlowMap);
m_pTextureGlowMap = NULL;
if (m_pTextureBlur != NULL)
m_pTextureGlowMap = nullptr;
if (m_pTextureBlur != nullptr)
textureCache().removeFrameBufferTexture(m_pTextureBlur);
m_pTextureBlur = NULL;
m_pTextureBlur = nullptr;
}
void PostProcessor::destroy()
{
_destroyBlur();
_destroyGammaCorrection();
_destroyCommon();
}
PostProcessor & PostProcessor::get()
@ -443,16 +502,8 @@ void _setGLState() {
gDP.changed |= CHANGED_RENDERMODE;
}
void PostProcessor::doBlur(FrameBuffer * _pBuffer)
void PostProcessor::_preDraw(FrameBuffer * _pBuffer)
{
if (config.bloomFilter.enable == 0)
return;
if (_pBuffer == NULL || (_pBuffer->m_postProcessed&PostProcessor::postEffectBlur) == PostProcessor::postEffectBlur)
return;
_pBuffer->m_postProcessed |= PostProcessor::postEffectBlur;
_setGLState();
OGLVideo & ogl = video();
@ -472,6 +523,26 @@ void PostProcessor::doBlur(FrameBuffer * _pBuffer)
#endif
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
}
void PostProcessor::_postDraw()
{
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
video().getRender().dropRenderState();
glUseProgram(0);
}
void PostProcessor::doBlur(FrameBuffer * _pBuffer)
{
if (config.bloomFilter.enable == 0)
return;
if (_pBuffer == nullptr || (_pBuffer->m_postProcessed&PostProcessor::postEffectBlur) == PostProcessor::postEffectBlur)
return;
_pBuffer->m_postProcessed |= PostProcessor::postEffectBlur;
_preDraw(_pBuffer);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_FBO_glowMap);
textureCache().activateTexture(0, m_pTextureOriginal);
@ -497,7 +568,27 @@ void PostProcessor::doBlur(FrameBuffer * _pBuffer)
glUseProgram(m_glowProgram);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
video().getRender().dropRenderState();
glUseProgram(0);
_postDraw();
}
void PostProcessor::doGammaCorrection(FrameBuffer * _pBuffer)
{
if (((*REG.VI_STATUS & 8)|config.gammaCorrection.force) == 0)
return;
if (_pBuffer == nullptr || (_pBuffer->m_postProcessed&PostProcessor::postEffectGammaCorrection) == PostProcessor::postEffectGammaCorrection)
return;
_pBuffer->m_postProcessed |= PostProcessor::postEffectGammaCorrection;
_preDraw(_pBuffer);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, _pBuffer->m_FBO);
textureCache().activateTexture(0, m_pTextureOriginal);
glUseProgram(m_gammaCorrectionProgram);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
_postDraw();
}

13
src/PostProcessor.h
View File

@ -11,19 +11,28 @@ public:
void destroy();
void doBlur(FrameBuffer * _pBuffer);
void doGammaCorrection(FrameBuffer * _pBuffer);
static PostProcessor & get();
static const u32 postEffectBlur = 1U;
static const u32 postEffectGammaCorrection = 2U;
private:
PostProcessor() :
m_extractBloomProgram(0), m_seperableBlurProgram(0), m_glowProgram(0), m_bloomProgram(0), m_copyProgram(0),
m_extractBloomProgram(0), m_seperableBlurProgram(0),
m_glowProgram(0), m_bloomProgram(0), m_copyProgram(0), m_gammaCorrectionProgram(0),
m_FBO_original(0), m_FBO_glowMap(0), m_FBO_blur(0),
m_pTextureOriginal(NULL), m_pTextureGlowMap(NULL), m_pTextureBlur(NULL) {}
PostProcessor(const PostProcessor & _other);
void _initCommon();
void _destroyCommon();
void _initGammaCorrection();
void _destroyGammaCorrection();
void _initBlur();
void _destroyBlur();
void _preDraw(FrameBuffer * _pBuffer);
void _postDraw();
GLuint m_extractBloomProgram;
GLuint m_seperableBlurProgram;
@ -31,6 +40,8 @@ private:
GLuint m_bloomProgram;
GLuint m_copyProgram;
GLuint m_gammaCorrectionProgram;
GLuint m_FBO_original;
GLuint m_FBO_glowMap;
GLuint m_FBO_blur;

16
src/mupenplus/Config_mupenplus.cpp
View File

@ -70,10 +70,6 @@ bool Config_SetDefault()
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "EnableShadersStorage", config.generalEmulation.enableShadersStorage, "Use persistent storage for compiled shaders.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "ForceGammaCorrection", config.generalEmulation.forceGammaCorrection, "Force gamma correction.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultFloat(g_configVideoGliden64, "GammaCorrectionLevel", config.generalEmulation.gammaCorrectionLevel, "Gamma correction level.");
assert(res == M64ERR_SUCCESS);
#ifdef ANDROID
res = ConfigSetDefaultBool(g_configVideoGliden64, "ForcePolygonOffset", config.generalEmulation.forcePolygonOffset, "If true, use polygon offset values specified below");
assert(res == M64ERR_SUCCESS);
@ -143,6 +139,12 @@ bool Config_SetDefault()
res = ConfigSetDefaultInt(g_configVideoGliden64, "blurStrength", config.bloomFilter.blurStrength, "Blur strength. Values [10, 100]");
assert(res == M64ERR_SUCCESS);
//#Gamma correction settings
res = ConfigSetDefaultBool(g_configVideoGliden64, "ForceGammaCorrection", config.gammaCorrection.force, "Force gamma correction.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultFloat(g_configVideoGliden64, "GammaCorrectionLevel", config.gammaCorrection.level, "Gamma correction level.");
assert(res == M64ERR_SUCCESS);
return ConfigSaveSection("Video-GLideN64") == M64ERR_SUCCESS;
}
@ -189,8 +191,6 @@ void Config_LoadConfig()
config.generalEmulation.enableLOD = ConfigGetParamBool(g_configVideoGliden64, "EnableLOD");
config.generalEmulation.enableHWLighting = ConfigGetParamBool(g_configVideoGliden64, "EnableHWLighting");
config.generalEmulation.enableShadersStorage = ConfigGetParamBool(g_configVideoGliden64, "EnableShadersStorage");
config.generalEmulation.forceGammaCorrection = ConfigGetParamBool(g_configVideoGliden64, "ForceGammaCorrection");
config.generalEmulation.gammaCorrectionLevel = ConfigGetParamFloat(g_configVideoGliden64, "GammaCorrectionLevel");
#ifdef ANDROID
config.generalEmulation.forcePolygonOffset = ConfigGetParamBool(g_configVideoGliden64, "ForcePolygonOffset");
config.generalEmulation.polygonOffsetFactor = ConfigGetParamFloat(g_configVideoGliden64, "PolygonOffsetFactor");
@ -244,5 +244,9 @@ void Config_LoadConfig()
config.bloomFilter.blurAmount = ConfigGetParamInt(g_configVideoGliden64, "blurAmount");
config.bloomFilter.blurStrength = ConfigGetParamInt(g_configVideoGliden64, "blurStrength");
//#Gamma correction settings
config.gammaCorrection.force = ConfigGetParamBool(g_configVideoGliden64, "ForceGammaCorrection");
config.gammaCorrection.level = ConfigGetParamFloat(g_configVideoGliden64, "GammaCorrectionLevel");
config.generalEmulation.hacks = hacks;
}