[default]
; default of this CVarGroup
= 4

r_DepthOfField=2
r_MotionBlur=2
r_sunshafts=1
r_UseEdgeAA=1
r_Flares=1
r_Coronas=1
r_colorgrading=2
r_GlowAnamorphicFlares = 1

[1]
r_DepthOfField=0
r_MotionBlur=0
r_Flares=1
r_Coronas=1
r_UseEdgeAA=0
r_sunshafts=0
r_colorgrading=0

[2]
r_DepthOfField=1
r_sunshafts=0
r_MotionBlur=0
r_UseEdgeAA=0
r_colorgrading=2

[3]
r_DepthOfField=1
r_sunshafts=0
r_MotionBlur=1
r_colorgrading=2

[default]
; default of this CVarGroup
= 4

sys_spec_ObjectDetail=4
sys_spec_Shading=4
sys_spec_VolumetricEffects=4
sys_spec_Shadows=4
sys_spec_Texture=4
sys_spec_Physics=4
sys_spec_PostProcessing=4
sys_spec_Particles=4
sys_spec_Sound=4
sys_spec_Water=4
sys_spec_GameEffects=4

[1]
sys_spec_ObjectDetail=1
sys_spec_Shading=1
sys_spec_VolumetricEffects=1
sys_spec_Shadows=1
sys_spec_Texture=1
sys_spec_Physics=1
sys_spec_PostProcessing=1
sys_spec_Particles=1
sys_spec_Sound=1
sys_spec_Water=1
sys_spec_GameEffects=1

[2]
sys_spec_ObjectDetail=2
sys_spec_Shading=2
sys_spec_VolumetricEffects=2
sys_spec_Shadows=2
sys_spec_Texture=2
sys_spec_Physics=2
sys_spec_PostProcessing=2
sys_spec_Particles=2
sys_spec_Sound=2
sys_spec_Water=2
sys_spec_GameEffects=2

[3]
sys_spec_ObjectDetail=3
sys_spec_Shading=3
sys_spec_VolumetricEffects=3
sys_spec_Shadows=3
sys_spec_Texture=3
sys_spec_Physics=3
sys_spec_PostProcessing=3
sys_spec_Particles=3
sys_spec_Sound=3
sys_spec_Water=3
sys_spec_GameEffects=3

void CColorGrading::UpdateParams( SColorGradingMergeParams &pMergeParams )
{
float fSharpenAmount = max(m_pSharpenAmount->GetParam(), 0.0f);

// add cvar color_grading/color_grading_levels/color_grading_selectivecolor/color_grading_filters

// Clamp to same Photoshop min/max values
float fMinInput = clamp_tpl<float>(m_pMinInput->GetParam(), 0.0f, 255.0f);
float fGammaInput = clamp_tpl<float>(m_pGammaInput->GetParam(), 0.0f, 10.0f);;
float fMaxInput = clamp_tpl<float>(m_pMaxInput->GetParam(), 0.0f, 255.0f);
float fMinOutput = clamp_tpl<float>(m_pMinOutput->GetParam(), 0.0f, 255.0f);

float fMaxOutput = clamp_tpl<float>(m_pMaxOutput->GetParam(), 0.0f, 255.0f);

float fBrightness = m_pBrightness->GetParam();
float fContrast = m_pContrast->GetParam();
float fSaturation = m_pSaturation->GetParam() + m_pSaturationOffset->GetParam();
Vec4 pFilterColor = m_pPhotoFilterColor->GetParamVec4() + m_pPhotoFilterColorOffset->GetParamVec4();
float fFilterColorDensity = clamp_tpl<float>(m_pPhotoFilterColorDensity->GetParam() + m_pPhotoFilterColorDensityOffset->GetParam(), 0.0f, 1.0f);
float fGrain = min(m_pGrainAmount->GetParam()+m_pGrainAmountOffset->GetParam(), 1.0f);

Vec4 pSelectiveColor = m_pSelectiveColor->GetParamVec4();
float fSelectiveColorCyans = clamp_tpl<float>(m_pSelectiveColorCyans->GetParam()*0.01f, -1.0f, 1.0f);
float fSelectiveColorMagentas = clamp_tpl<float>(m_pSelectiveColorMagentas->GetParam()*0.01f, -1.0f, 1.0f);
float fSelectiveColorYellows = clamp_tpl<float>(m_pSelectiveColorYellows->GetParam()*0.01f, -1.0f, 1.0f);
float fSelectiveColorBlacks = clamp_tpl<float>(m_pSelectiveColorBlacks->GetParam()*0.01f, -1.0f, 1.0f);

// Saturation matrix
Matrix44 pSaturationMat;
{
float y=0.3086f, u=0.6094f, v=0.0820f, s=clamp_tpl<float>(fSaturation, -1.0f, 100.0f);

float a = (1.0f-s)*y + s;
float b = (1.0f-s)*y;
float c = (1.0f-s)*y;
float d = (1.0f-s)*u;
float e = (1.0f-s)*u + s;
float f = (1.0f-s)*u;
float g = (1.0f-s)*v;
float h = (1.0f-s)*v;
float i = (1.0f-s)*v + s;

pSaturationMat.SetIdentity();
pSaturationMat.SetRow(0, Vec3(a, d, g));
pSaturationMat.SetRow(1, Vec3(b, e, h));
pSaturationMat.SetRow(2, Vec3(c, f, i));
}

// Brightness matrix
Matrix44 pBrightMat;
fBrightness=clamp_tpl<float>(fBrightness, 0.0f, 100.0f);
pBrightMat.SetIdentity();
pBrightMat.SetRow(0, Vec3(fBrightness, 0, 0));
pBrightMat.SetRow(1, Vec3(0, fBrightness, 0));
pBrightMat.SetRow(2, Vec3(0, 0, fBrightness));

// Create Contrast matrix
Matrix44 pContrastMat;
{
float c=clamp_tpl<float>(fContrast, -1.0f, 100.0f);
pContrastMat.SetIdentity();
pContrastMat.SetRow(0, Vec3(c, 0, 0));
pContrastMat.SetRow(1, Vec3(0, c, 0));
pContrastMat.SetRow(2, Vec3(0, 0, c));
pContrastMat.SetColumn(3, 0.5f*Vec3(1.0f-c, 1.0f-c, 1.0f-c));
}

// Compose final color matrix and set fragment program constants
Matrix44 pColorMat = pSaturationMat * (pBrightMat * pContrastMat);

Vec4 pParams0 = Vec4(fMinInput, fGammaInput, fMaxInput, fMinOutput);
Vec4 pParams1 = Vec4(fMaxOutput, fGrain, cry_rand()%1024, cry_rand()%1024);
Vec4 pParams2 = Vec4(pFilterColor.x, pFilterColor.y, pFilterColor.z, fFilterColorDensity);
Vec4 pParams3 = Vec4(pSelectiveColor.x, pSelectiveColor.y, pSelectiveColor.z, fSharpenAmount + 1.0f);
Vec4 pParams4 = Vec4(fSelectiveColorCyans, fSelectiveColorMagentas, fSelectiveColorYellows, fSelectiveColorBlacks);

// Enable corresponding shader variation
pMergeParams.nFlagsShaderRT = gRenDev->m_RP.m_FlagsShader_RT;
pMergeParams.nFlagsShaderRT &= ~(g_HWSR_MaskBit[HWSR_SAMPLE0]|g_HWSR_MaskBit[HWSR_SAMPLE1]|g_HWSR_MaskBit[HWSR_
SAMPLE2]|g_HWSR_MaskBit[HWSR_SAMPLE3]|g_HWSR_MaskBit[HWSR_SAMPLE4]);

#if !defined(XENON) && !defined(PS3)
if( CRenderer::CV_r_colorgrading_levels && (fMinInput || fGammaInput || fMaxInput || fMinOutput ||fMaxOutput) )
pMergeParams.nFlagsShaderRT |= g_HWSR_MaskBit[HWSR_SAMPLE0];
#endif

if( CRenderer::CV_r_colorgrading_filters && (fFilterColorDensity || fGrain || fSharpenAmount))
{
if( fFilterColorDensity )
pMergeParams.nFlagsShaderRT |= g_HWSR_MaskBit[HWSR_SAMPLE4];
if( fGrain || fSharpenAmount )
pMergeParams.nFlagsShaderRT |= g_HWSR_MaskBit[HWSR_SAMPLE1];
}

if( CRenderer::CV_r_colorgrading_selectivecolor && (fSelectiveColorCyans || fSelectiveColorMagentas || fSelectiveColorYellows || fSelectiveColorBlacks))
pMergeParams.nFlagsShaderRT |= g_HWSR_MaskBit[HWSR_SAMPLE2];

if (CRenderer::CV_r_colorgrading_charts && CRenderer::CV_r_colorgrading == 2)
pMergeParams.nFlagsShaderRT |= g_HWSR_MaskBit[HWSR_SAMPLE3];

Matrix44 pColorMatFromUserAndTOD = GetUtils().GetColorMatrix();
pColorMat = pColorMat * pColorMatFromUserAndTOD;

Vec4 pColorMatrix[3]=
{
Vec4(pColorMat.m00, pColorMat.m01, pColorMat.m02, pColorMat.m03),
Vec4(pColorMat.m10, pColorMat.m11, pColorMat.m12, pColorMat.m13),
Vec4(pColorMat.m20, pColorMat.m21, pColorMat.m22, pColorMat.m23),
};

pMergeParams.pColorMatrix[0] = pColorMatrix[0];
pMergeParams.pColorMatrix[1] = pColorMatrix[1];
pMergeParams.pColorMatrix[2] = pColorMatrix[2];
pMergeParams.pLevels[0] = pParams0;
pMergeParams.pLevels[1] = pParams1;
pMergeParams.pFilterColor = pParams2;
pMergeParams.pSelectiveColor[0] = pParams3;
pMergeParams.pSelectiveColor[1] = pParams4;

if (gcpRendD3D->m_pColorGradingControllerD3D)
{
if( CRenderer::CV_r_colorgrading == 2)
{
gcpRendD3D->m_pColorGradingControllerD3D->Update(&pMergeParams);
}
else
gcpRendD3D->m_pColorGradingControllerD3D->Update();
}

// If using merged color grading with color chart disable regular color transformations in display - only need to use color chart
if( CRenderer::CV_r_colorgrading == 2)
pMergeParams.nFlagsShaderRT &= ~(g_HWSR_MaskBit[HWSR_SAMPLE0]|g_HWSR_MaskBit[HWSR_SAMPLE2]|g_HWSR_MaskBit[HWSR_
SAMPLE4]);

}

bool CWaterDroplets::Preprocess()
{
bool bQualityCheck = CPostEffectsMgr::CheckPostProcessQuality( eRQ_Medium, eSQ_Medium );
if( !bQualityCheck )
return false;

bool bUserActive = m_pAmount->GetParam() > 0.005f;

if( iSystem->IsEditorMode() && !bUserActive )
return false;

if( CRenderer::CV_r_water_godrays)
{
float fWatLevel = SPostEffectsUtils::m_fWaterLevel;
if( fWatLevel - 0.1f > gRenDev->GetRCamera().Orig.z)
{
m_fLastSpawnTime = 0.0f;
m_fCurrLifeTime = 0.0;
m_bWasUnderWater = true;
return false;
}
else
m_bWasUnderWater = false;

// Coming out of water
if( m_bWasUnderWater == false && m_fCurrLifeTime <1.0f)
{
const float fLifeTime = 1.5f;

if( !m_fLastSpawnTime )
m_fLastSpawnTime = gEnv->pTimer->GetCurrTime();

m_fCurrLifeTime = (gEnv->pTimer->GetCurrTime() - m_fLastSpawnTime) / fLifeTime;
if( m_fCurrLifeTime >= 1.0f)
{
if( !bUserActive ) // user enabled override
return false;
}

// check water level
return true;
}

if( bUserActive ) // user enabled override
return true;
}

return false;
}

void CWaterDroplets::Reset()
{
m_fLastSpawnTime = 0.0f;
m_fCurrLifeTime = 1000.0f;
m_bWasUnderWater = true;
m_pAmount->ResetParam(0.0f);
}

void CWaterDroplets::Render()
{
// float fDropletsAmount = m_pAmount->GetParam();

static CCryName pTechName("WaterDroplets");
GetUtils().ShBeginPass(CShaderMan::m_shPostEffectsGame, pTechName, FEF_DONTSETSTATES);

gcpRendD3D->EF_SetState(GS_NODEPTHTEST);

float fUserAmount = m_pAmount->GetParam();

float fAtten = clamp_tpl<float>(fabs( gRenDev->GetRCamera().Orig.z - SPostEffectsUtils::m_fWaterLevel ), 0.0f, 1.0f);
Vec4 vParams=Vec4(1, 1, 1, min(fUserAmount + (1.0f - clamp_tpl<float>(m_fCurrLifeTime, 0.0f, 1.0f)), 1.0f) * fAtten);
static CCryName pParamName("waterDropletsParams");
CShaderMan::m_shPostEffectsGame->FXSetPSFloat(pParamName, &vParams, 1);

GetUtils().DrawFullScreenQuad(CTexture::s_ptexBackBuffer->GetWidth(), CTexture::s_ptexBackBuffer->GetHeight());

GetUtils().ShEndPass();
}