void CBaseVSShader::SetPixelShaderConstantGammaToLinear( int pixelReg, int constantVar, int constantVar2 ) { Assert( !IsSnapshotting() ); if ((!s_ppParams) || (constantVar == -1) || (constantVar2 == -1)) return; IMaterialVar* pPixelVar = s_ppParams[constantVar]; Assert( pPixelVar ); IMaterialVar* pPixelVar2 = s_ppParams[constantVar2]; Assert( pPixelVar2 ); float val[4]; if (pPixelVar->GetType() == MATERIAL_VAR_TYPE_VECTOR) { pPixelVar->GetVecValue( val, 3 ); } else { val[0] = val[1] = val[2] = pPixelVar->GetFloatValue(); } val[3] = pPixelVar2->GetFloatValue(); val[0] = val[0] > 1.0f ? val[0] : GammaToLinear( val[0] ); val[1] = val[1] > 1.0f ? val[1] : GammaToLinear( val[1] ); val[2] = val[2] > 1.0f ? val[2] : GammaToLinear( val[2] ); s_pShaderAPI->SetPixelShaderConstant( pixelReg, val ); }
//----------------------------------------------------------------------------- // Helpers for dealing with envmap tint //----------------------------------------------------------------------------- // set alphaVar to -1 to ignore it. void CBaseVSShader::SetEnvMapTintPixelShaderDynamicState( int pixelReg, int tintVar, int alphaVar, bool bConvertFromGammaToLinear ) { float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; if( g_pConfig->bShowSpecular && mat_fullbright.GetInt() != 2 ) { IMaterialVar* pAlphaVar = NULL; if( alphaVar >= 0 ) { pAlphaVar = s_ppParams[alphaVar]; } if( pAlphaVar ) { color[3] = pAlphaVar->GetFloatValue(); } IMaterialVar* pTintVar = s_ppParams[tintVar]; #ifdef _DEBUG pTintVar->GetVecValue( color, 3 ); float envmapTintOverride = mat_envmaptintoverride.GetFloat(); float envmapTintScaleOverride = mat_envmaptintscale.GetFloat(); if( envmapTintOverride != -1.0f ) { color[0] = color[1] = color[2] = envmapTintOverride; } if( envmapTintScaleOverride != -1.0f ) { color[0] *= envmapTintScaleOverride; color[1] *= envmapTintScaleOverride; color[2] *= envmapTintScaleOverride; } if( bConvertFromGammaToLinear ) { color[0] = color[0] > 1.0f ? color[0] : GammaToLinear( color[0] ); color[1] = color[1] > 1.0f ? color[1] : GammaToLinear( color[1] ); color[2] = color[2] > 1.0f ? color[2] : GammaToLinear( color[2] ); } #else if( bConvertFromGammaToLinear ) { pTintVar->GetLinearVecValue( color, 3 ); } else { pTintVar->GetVecValue( color, 3 ); } #endif } else { color[0] = color[1] = color[2] = color[3] = 0.0f; } s_pShaderAPI->SetPixelShaderConstant( pixelReg, color, 1 ); }
void UTIL_ColorStringToLinearFloatColor( Vector &color, const char *pString ) { float tmp[4]; UTIL_StringToFloatArray( tmp, 4, pString ); if( tmp[3] <= 0.0f ) { tmp[3] = 255.0f; } tmp[3] *= ( 1.0f / 255.0f ); color.x = GammaToLinear( tmp[0] * ( 1.0f / 255.0f ) ) * tmp[3]; color.y = GammaToLinear( tmp[1] * ( 1.0f / 255.0f ) ) * tmp[3]; color.z = GammaToLinear( tmp[2] * ( 1.0f / 255.0f ) ) * tmp[3]; }
void CBaseVSShader::SetVertexShaderConstantGammaToLinear( int var, float const* pVec, int numConst, bool bForce ) { int i; for( i = 0; i < numConst; i++ ) { float vec[4]; vec[0] = pVec[i*4+0] > 1.0f ? pVec[i*4+0] : GammaToLinear( pVec[i*4+0] ); vec[1] = pVec[i*4+1] > 1.0f ? pVec[i*4+1] : GammaToLinear( pVec[i*4+1] ); vec[2] = pVec[i*4+2] > 1.0f ? pVec[i*4+2] : GammaToLinear( pVec[i*4+2] ); vec[3] = pVec[i*4+3]; s_pShaderAPI->SetVertexShaderConstant( var + i, vec, 1, bForce ); } }