ppeffects.c

Go to the documentation of this file.

class PPEffects
{
 // COLORIZE IDs
 static const int COLORIZE_NV = 100;
 
 //CONSTANTS
 static const float COLOR_SHOCK = 0.1;//shock color value (relative) //todo
 
 //-------------------------------------------------------
 // BLUR START
 //-------------------------------------------------------
 static int m_BlurInventory;
 static int m_BlurDrunk;
 static int m_BlurFever;
 static int m_BlurMenu;
 static int m_BlurOptics;
 static int m_BlurFlashbang;
 static int m_BlurShock;
 
 static int m_BurlapBlindness;
 static int m_DyingEffect;
 static int m_ShockEffect;
 
 static int m_ChromAbbOptic;
 //static int m_ChromAbbShock;
 
 static int m_VignetteUnconscious;
 static int m_VignetteShock;
 static int m_VignetteTunnel;
 static int m_VignetteMenu;
 
 static float m_BloodSaturation;
 
 static ref array<float> m_BlurValues;
 static ref array<float> m_ChromAbbValues;
 static ref array<int> m_VignetteEffects;
 static ref map<int, ref array<float>> m_VignetteValues;
 static ref map<int, ref array<float>> m_ColorValues;
 static ref array<float> m_ColorEffect;
 static ref map<int, ref array<float>> m_ColorizeEffects;
 
 //static float m_UnconsciousVignetteColor[4];
 //static float m_UnconsciousVignetteIntesity;
 
 static float m_ColorValueTotal[4] = {0,0,0,0};
 static float m_ColorOverlayTotal;
 
 static Material m_MatColors;
 static Material m_RadialBlur;
 
 static void Init()
 {
 //Print("---Init PPEffects---");
 if ( m_BlurValues )
 {
 delete m_BlurValues;
 }
 if ( m_ChromAbbValues )
 {
 delete m_ChromAbbValues;
 }
 if ( m_VignetteEffects )
 {
 delete m_VignetteEffects;
 }
 if ( m_VignetteValues )
 {
 delete m_VignetteValues;
 }
 if ( m_ColorEffect )
 {
 delete m_ColorEffect;
 }
 
 m_MatColors = GetGame().GetWorld().GetMaterial("graphics/materials/postprocess/glow");
 m_RadialBlur = GetGame().GetWorld().GetMaterial("graphics/materials/postprocess/radialblur");
 m_BlurValues = new array<float>;
 m_ChromAbbValues = new array<float>;
 m_VignetteEffects = new array<int>;
 m_VignetteValues = new map<int, ref array<float>>;
 
 // add new blur effects here
 m_BlurInventory = RegisterBlurEffect();
 m_BlurDrunk = RegisterBlurEffect();
 m_BlurFever = RegisterBlurEffect();
 m_BlurMenu = RegisterBlurEffect();
 m_BlurOptics = RegisterBlurEffect();
 m_BlurFlashbang = RegisterBlurEffect();
 
 // add chromatic abberation effects here
 m_ChromAbbOptic = RegisterChromAbbEffect();
 //m_ChromAbbShock = RegisterChromAbbEffect();
 
 // add vignette effects here
 m_VignetteUnconscious = RegisterVignetteEffect();
 m_VignetteShock = RegisterVignetteEffect();
 m_VignetteTunnel = RegisterVignetteEffect();
 m_VignetteMenu = RegisterVignetteEffect();
 
 m_ColorEffect = new array<float>;
 m_ColorValues = new map<int, ref array<float>>;
 
 // add new color effects here
 m_BurlapBlindness = RegisterColorEffect();
 m_DyingEffect = RegisterColorEffect();
 m_ShockEffect = RegisterColorEffect();
 
 // ------------------------NV-related stuff below------------------------
 array<float> colorizeDefault = {0.0, 0.0, 0.0};
 m_ColorizeEffects = new map<int, ref array<float>>;
 
 // colorize: r, g, b
 // colorize effects registration
 m_ColorizeEffects.Set(PPEffects.COLORIZE_NV, colorizeDefault);
 //SetNVParams(1.0, 0.0, 2.35, 2.75); //default values
 // ------------------------End of NV-related stuff------------------------
 }
 
 static void ResetBlurEffects()
 { 
 if( m_BlurValues )
 {
 for ( int i = 0; i < m_BlurValues.Count(); ++i )
 {
 m_BlurValues[i] = 0;
 }
 UpdateBlur();
 }
 }
 
 static void ResetRadialBlur()
 { 
 SetRadialBlur(0,0,0,0);
 }
 
 static void SetBlurValue(int index, float value)
 {
 if ( m_BlurValues && index < m_BlurValues.Count() )
 {
 m_BlurValues[index] = value;
 }
 else
 {
 Print("Error: PPEffects: m_BlurValues with index: "+ index +" is not registered.");
 }
 }
 
 static int RegisterBlurEffect()
 {
 return m_BlurValues.Insert(0);
 }
 
 //-------------------------------------------------------
 static void SetRadialBlur(float powerX, float powerY, float offsetX, float offsetY )
 {
 if (GetGame())
 {
 m_RadialBlur.SetParam("PowerX", powerX);
 m_RadialBlur.SetParam("PowerY", powerY);
 m_RadialBlur.SetParam("OffsetX", offsetX);
 m_RadialBlur.SetParam("OffsetY", offsetY);
 }
 }
 //-------------------------------------------------------
 static void SetBlur(float value)
 {
 if (GetGame())
 {
 Material mat_blur = GetGame().GetWorld().GetMaterial("graphics/materials/postprocess/gauss");
 
 if (mat_blur)
 {
 mat_blur.SetParam("Intensity", value);
 }
 }
 }
 //-------------------------------------------------------
 static void UpdateBlur()
 { 
 float blur_value_total = 0;
 if( m_BlurValues )
 {
 for ( int i = 0; i < m_BlurValues.Count(); ++i )
 {
 blur_value_total += m_BlurValues[i];
 }
 }
 
 SetBlur( blur_value_total );
 }
 //-------------------------------------------------------
 static void SetBlurInventory(float value)
 {
 SetBlurValue(m_BlurInventory, value);
 UpdateBlur();
 }
 //-------------------------------------------------------
 static void SetBlurDrunk(float value)
 {
 SetBlurValue(m_BlurDrunk, value);
 UpdateBlur();
 }
 
 //-------------------------------------------------------
 static void SetBlurFever(float value)
 {
 SetBlurValue(m_BlurFever, value);
 UpdateBlur();
 }
 
 //-------------------------------------------------------
 static void SetBlurMenu(float value)
 {
 SetBlurValue(m_BlurMenu, value);
 UpdateBlur();
 }
 
 //-------------------------------------------------------
 static void SetBlurOptics(float value)
 {
 SetBlurValue(m_BlurOptics, value);
 UpdateBlur();
 }
 
 //-------------------------------------------------------
 static void SetBlurFlashbang(float value)
 {
 SetBlurValue(m_BlurFlashbang, value);
 UpdateBlur();
 }
 
 static void SetBlurShock(float value)
 {
 SetBlurValue(m_BlurShock, value);
 UpdateBlur();
 }
 
 //-------------------------------------------------------
 // BLUR END
 //-------------------------------------------------------
 
 //-------------------------------------------------------
 // CHROMATIC ABBERATION
 //-------------------------------------------------------
 static int RegisterChromAbbEffect()
 {
 return m_ChromAbbValues.Insert(0);
 }
 
 static void ResetChromAbbEffects()
 { 
 if( m_ChromAbbValues )
 {
 for ( int i = 0; i < m_ChromAbbValues.Count(); ++i )
 {
 m_ChromAbbValues[i] = 0;
 }
 UpdateChromAbb();
 } 
 }
 
 static void SetChromAbbValue(int index, float value)
 {
 if ( m_ChromAbbValues && index < m_ChromAbbValues.Count() )
 {
 m_ChromAbbValues[index] = value;
 }
 else
 {
 Print("Error: PPEffects: m_ChromAbbValues with index: "+ index +" is not registered.");
 }
 }
 
 static void SetChromAbb(float value)
 {
 if (GetGame())
 {
 if (m_MatColors)
 {
 //Print("SetChromAbb: " + value);
 m_MatColors.SetParam("MaxChromAbberation", value);
 //SetVignette(value,0,255,0);
 }
 }
 }
 //-------------------------------------------------------
 static void UpdateChromAbb()
 { 
 float chromabb_value_total = 0;
 if( m_ChromAbbValues )
 {
 for ( int i = 0; i < m_ChromAbbValues.Count(); ++i )
 {
 chromabb_value_total += m_ChromAbbValues[i]; //currently additive!
 }
 }
 
 SetChromAbb( chromabb_value_total );
 }
 
 static void SetChromAbbOptic(float value)
 {
 SetChromAbbValue(m_ChromAbbOptic, value);
 UpdateChromAbb();
 }
 
 /*static void SetChromAbbShock(float value)
 {
 SetChromAbbValue(m_ChromAbbShock, value);
 UpdateChromAbb();
 }*/
 
 //-------------------------------------------------------
 // CHROMATIC ABBERATION END
 //-------------------------------------------------------
 
 /*
 static void SetOverlayColor(float r, float g, float b, float a)
 {
 Material matColors = GetGame().GetWorld().GetMaterial("graphics/materials/postprocess/glow");
 
 m_Color[0] = r;
 m_Color[1] = g;
 m_Color[2] = b;
 m_Color[3] = a;
 
 matColors.SetParam("OverlayColor", m_Color);
 matColors.SetParam("OverlayFactor", a);
 
 }*/
 
 static void ResetColorEffects()
 {
 if( m_ColorEffect )
 {
 for ( int i = 0; i < m_ColorEffect.Count(); ++i )
 {
 //m_ColorEffect[i] = 0;
 m_ColorValues.Set(i,{0,0,0,0,0});
 }
 UpdateColor();
 }
 }
 
 static void SetColorValue(int index, float r, float g, float b, float a, float overlay)
 {
 if ( index < m_ColorEffect.Count() )
 {
 array<float> values = {r,g,b,a,overlay};
 
 m_ColorValues.Set(index, values);
 }
 else
 {
 Print("Error: PPEffects: m_ColorValues with index: "+ index +" is not registered.");
 }
 }
 
 static int RegisterColorEffect()
 {
 return m_ColorEffect.Insert(0);
 } 
 
 static void UpdateColor()
 {
 float color_value_total[4] = {0,0,0,0};
 float color_overlay;
 /*
 m_MatColors.ResetParam("OverlayColor");
 m_MatColors.ResetParam("OverlayFactor");
 */
 if( !GetGame() || !GetGame().GetWorld() )
 {
 return;
 }
 
 for ( int i = 0; i < m_ColorValues.Count(); ++i )
 {
 int key = m_ColorValues.GetKey(i);
 array<float> value = m_ColorValues.Get(key);
 
 color_value_total[0] = color_value_total[0] + value[0];
 color_value_total[1] = color_value_total[1] + value[1];
 color_value_total[2] = color_value_total[2] + value[2];
 color_value_total[3] = color_value_total[3] + value[3];
 color_overlay += value[4];
 }
 
 m_ColorValueTotal = color_value_total;
 m_ColorOverlayTotal = color_overlay;
 m_MatColors.SetParam("OverlayColor", color_value_total);
 m_MatColors.SetParam("OverlayFactor", color_overlay); 
 }
 
 static void SetLensEffect(float lens, float chromAbb, float centerX, float centerY)
 {
 PerformSetLensEffect(lens, chromAbb, centerX, centerY);
 }
 
 static void PerformSetLensEffect(float lens, float chromAbb, float centerX, float centerY)
 {
 m_MatColors.SetParam("LensDistort", lens);
 SetChromAbbOptic(chromAbb);
 m_MatColors.SetParam("LensCenterX", centerX);
 m_MatColors.SetParam("LensCenterY", centerY);
 }
 
 static void SetVignette(float intensity, float R, float G, float B, float A)
 {
 float color[4];
 color[0] = R;
 color[1] = G;
 color[2] = B;
 color[3] = A;
 
 m_MatColors.SetParam("Vignette", intensity);
 m_MatColors.SetParam("VignetteColor", color);
 }
 
 static void SetVignetteEffectValue(int index, float intensity, float r, float g, float b, float a)
 {
 if ( index < m_VignetteEffects.Count() )
 {
 array<float> values = {intensity,r,g,b,a};
 
 m_VignetteValues.Set(index, values);
 }
 else
 {
 Print("Error: PPEffects: m_ColorValues with index: "+ index +" is not registered.");
 }
 }
 
 static int RegisterVignetteEffect()
 {
 return m_VignetteEffects.Insert(0);
 }
 
 static void SetUnconsciousnessVignette(float value)
 {
 SetVignetteEffectValue(m_VignetteUnconscious, value, 0,0,0,0); //todo
 UpdateVignette();
 }
 
 static void SetShockVignette(float value)
 {
 SetVignetteEffectValue(m_VignetteShock, value, 0,0,0,0); //todo
 UpdateVignette();
 }
 
 static void SetTunnelVignette(float value)
 {
 SetVignetteEffectValue(m_VignetteTunnel, value, 0,0,0,0); //todo
 UpdateVignette();
 }
 
 static void SetMenuVignette(float value)
 {
 SetVignetteEffectValue(m_VignetteMenu, value, 0,0,0,0); //todo
 UpdateVignette();
 }
 
 static void ResetVignettes()
 {
 if( m_VignetteValues )
 {
 for ( int i = 0; i < m_VignetteValues.Count(); ++i )
 {
 array<float> values = {0,0,0,0,0};
 
 m_VignetteValues.Set(i, values);
 }
 UpdateVignette();
 }
 }
 
 static void OverrideDOF(bool enable, float focusDistance, float focusLength, float focusLengthNear, float blur, float focusDepthOffset)
 {
 GetGame().OverrideDOF(enable, focusDistance, focusLength, focusLengthNear, blur, focusDepthOffset);
 }
 
 static void AddPPMask(float ndcX, float ndcY, float ndcRadius, float ndcBlur)
 {
 GetGame().AddPPMask(ndcX, ndcY, ndcRadius, ndcBlur);
 }
 
 static void ResetPPMask()
 {
 if( GetGame() ) GetGame().ResetPPMask();
 }
 
 static void ResetDOFOverride()
 {
 OverrideDOF(false,0,0,0,0,1);
 }
 
 static void ResetLensEffect()
 {
 SetLensEffect(0,0,0,0);
 }
 
 static void HitEffect(float value)
 {
 float m_HitEffectColor[4];
 m_HitEffectColor[0] = Math.Lerp(Math.Clamp(m_ColorValueTotal[0],0,1), 1, value);
 m_HitEffectColor[1] = 0;
 m_HitEffectColor[2] = 0;
 m_HitEffectColor[3] = Math.Lerp(Math.Clamp(m_ColorValueTotal[0],0,1), 1, value);
 /*
 Print("---------------------------");
 Print("m_ColorValueTotal[0]: " + m_ColorValueTotal[0]);
 Print("value: " + value);
 Print("---------------------------");
 Print("r: " + m_HitEffectColor[0]);
 Print("g: " + m_HitEffectColor[1]);
 Print("b: " + m_HitEffectColor[2]);
 Print("a: " + m_HitEffectColor[3]);
 */
 m_MatColors.SetParam("OverlayColor", m_HitEffectColor);
 m_MatColors.SetParam("OverlayFactor", 0.05);
 }
 
 static void SetShockEffectColor(float value)
 {
 if (value > 0)
 SetColorValue(m_ShockEffect, COLOR_SHOCK, COLOR_SHOCK, COLOR_SHOCK, 1, value);
 else
 SetColorValue(m_ShockEffect, 0, 0, 0, 1, value);
 UpdateColor();
 }
 
 static void FlashbangEffect(float value)
 {
 float hitEffectColor[4];
 hitEffectColor[0] = 1;
 hitEffectColor[1] = 1;
 hitEffectColor[2] = 1;
 hitEffectColor[3] = Math.Lerp(Math.Clamp(m_ColorValueTotal[0],0,1), 1, value);
 
 m_MatColors.SetParam("OverlayColor", hitEffectColor);
 m_MatColors.SetParam("OverlayFactor", 0.75);
 }
 
 static void EnableBurlapSackBlindness()
 {
 SetColorValue(m_BurlapBlindness, 0, 0, 0, 1, 1.0);
 UpdateColor();
 g_Game.SetEVValue(-5);
 }
 
 static void DisableBurlapSackBlindness()
 { 
 SetColorValue(m_BurlapBlindness, 0, 0, 0, 0, 0.0);
 UpdateColor();
 g_Game.SetEVValue(0);
 }
 
 static void SetDeathDarkening(float value) 
 {
 value = Math.Clamp(value,0,1);
 SetColorValue(m_DyingEffect, 0, 0, 0, 1, value);
 UpdateColor();
 if (value > 0.99)
 SetEVValuePP(-5); //additional "darkness" to avoid lens flare
 else
 SetEVValuePP(0);
 }
 
 static void UpdateSaturation()
 {
 m_MatColors.SetParam("Saturation", m_BloodSaturation/*+add_additional_modifiers_here*/);
 }
 
 static void UpdateVignette()
 {
 float color[4];
 float intesity;
 
 float intensity_value_total = 0; //use just the highest?
 if( m_VignetteEffects )
 {
 for ( int i = 0; i < m_VignetteEffects.Count(); ++i )
 {
 if (m_VignetteValues.Get(i))
 {
 /*color[0] = m_VignetteValues.Get(i)[1]; //red
 color[1] = m_VignetteValues.Get(i)[2]; //green
 color[2] = m_VignetteValues.Get(i)[3]; //blue
 color[3] = m_VignetteValues.Get(i)[4]; //alpha*/
 color[0] = m_VignetteValues.Get(i).Get(1); //red
 color[1] = m_VignetteValues.Get(i).Get(2); //green
 color[2] = m_VignetteValues.Get(i).Get(3); //blue
 color[3] = m_VignetteValues.Get(i).Get(4); //alpha
 
 intesity = m_VignetteValues.Get(i).Get(0);
 intensity_value_total += intesity;
 }
 else
 {
 //Print("no m_VignetteValues");
 }
 }
 }
 
 /*color[0] = m_UnconsciousVignetteColor[0];
 color[1] = m_UnconsciousVignetteColor[1];
 color[2] = m_UnconsciousVignetteColor[2];
 
 intesity = m_UnconsciousVignetteIntesity;*/
 
 SetVignette( intensity_value_total, color[0], color[1], color[2], color[3] );
 }
 
 static void SetBloodSaturation(float value)
 {
 m_BloodSaturation = value;
 UpdateSaturation();
 }
 
 /*static void SetUnconsciousnessVignette(float value)
 {
 m_UnconsciousVignetteIntesity = value;
 UpdateVignette();
 }
 
 static void RemoveUnconsciousnessVignette()
 {
 m_UnconsciousVignetteIntesity = 0;
 UpdateVignette();
 }*/
 
 // appropriate parts of the code will call these functions
 static void SetColorizationNV(float r, float g, float b)
 {
 array<float> colorizeArray = {r, g, b};
 m_ColorizeEffects.Set(PPEffects.COLORIZE_NV, colorizeArray);
 UpdateColorize();
 }
 
 static void UpdateColorize()
 {
 bool foundActiveEffect = false;
 int lowestKey = 1000000;
 array<float> chosenArray;
 // search for active effect with highest priority (lower value of key better)
 for (int i = 0; i < m_ColorizeEffects.Count(); i++)
 {
 int currentKey = m_ColorizeEffects.GetKey(i);
 array<float> colorizeValues = m_ColorizeEffects.Get(currentKey);
 // check for non-zero active effect
 for (int j = 0; j < colorizeValues.Count(); j++)
 {
 if (colorizeValues[j] != 0.0)
 {
 if (currentKey < lowestKey)
 {
 chosenArray = colorizeValues;
 lowestKey = currentKey;
 foundActiveEffect = true;
 break;
 }
 }
 }
 }
 if (foundActiveEffect)
 {
 float color[4];
 color[0] = chosenArray[0];
 color[1] = chosenArray[1];
 color[2] = chosenArray[2];
 color[3] = 0;
 m_MatColors.SetParam("ColorizationColor", color);
 }
 else
 {
 // no active event found, reset colorize effect
 ResetColorize();
 }
 }
 static void ResetColorize()
 {
 float color[4];
 color[0] = 1.0;
 color[1] = 1.0;
 color[2] = 1.0;
 color[3] = 0;
 m_MatColors.SetParam("ColorizationColor", color);
 }
 
 // EV check for NV optics
 static void SetEVValuePP(float value)
 {
 g_Game.SetEVValue(value);
 }
 
 // light multiplier and noise intensity (using filmgrainNV.emat!) for nvg
 // added other parameters for filmgrainNV.emat, sharpness and grain size
 static void SetNVParams(float light_mult, float noise_intensity, float sharpness, float grain_size)
 {
 Material matHDR = GetGame().GetWorld().GetMaterial("Graphics/Materials/postprocess/filmgrainNV");
/*#ifdef PLATFORM_CONSOLE
//worst-case scenario console fix!
 noise_intensity = 0.0;
#endif*/
 g_Game.NightVissionLightParams(light_mult, noise_intensity);
 matHDR.SetParam("Sharpness", sharpness);
 matHDR.SetParam("GrainSize", grain_size);
 }
 
 // bloom PP, experimental stuff
 static void SetBloom(float thres, float steep, float inten)
 {
 m_MatColors.SetParam("BloomThreshold", thres);
 m_MatColors.SetParam("BloomSteepness", steep);
 m_MatColors.SetParam("BloomIntensity", inten);
 }
 
 static void ResetAll()
 {
 ResetBlurEffects();
 ResetColorEffects();
 ResetVignettes();
 ResetPPMask();
 ResetDOFOverride();
 ResetLensEffect();
 SetBloodSaturation(1);
 //RemoveUnconsciousnessVignette();
 ResetColorize();
 } 
};