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();
  }
};