Класс PPERequester_GameplayBase

base, not to be used directly, would lead to layering collisions! Подробнее...

Защищенные члены
void	OnStart (Param par=null)
void	OnStop (Param par=null)
void	OnStop (Param par=null)
void	SetNVMode (int mode)
void	OnStart (Param par=null)
void	OnStop (Param par=null)
void	SetUndergroundExposureCoef (float coef)
void	OnStart (Param par=null)
void	OnUpdate (float delta)
override void	OnStop (Param par=null)
float	FadeColourMult (float x, float y, float deltaT)
void	OnStart (Param par=null)
void	OnStart (Param par=null)
void	OnUpdate (float delta)
void	SetStamina01 (float stamina01)
void	OnStart (Param par=null)
void	OnStop (Param par=null)
void	OnUpdate (float delta)
void	SetFlashbangIntensity (float intensity, float daytime_toggle)
void	OnStart (Param par=null)
void	OnStart (Param par=null)
void	OnStart (Param par=null)
void	OnStart (Param par=null)
void	OnStart (Param par=null)
void	OnUpdate (float delta)
void	ProcessSimulation (float delta)
void	SampleChannels (float time)
void	ReSampleChannels (float time)
void	ProcessFading (float delta)
void	SetPulseProgress (float progress)
void	FadeOutEffect (float targetTime)
void	OnStart (Param par=null)
void	OnStart (Param par=null)
void	OnStart (Param par=null)
void	OnUpdate (float delta)
override void	OnStop (Param par=null)
float	FadeColourMult (float x, float y, float deltaT)
void	OnStart (Param par=null)
void	OnStart (Param par=null)

Защищенные данные
int	m_CurrentMode
float	m_UGExposureCoef = 1.0
vector	m_StartRGB = vector.Zero
float	m_AccumulatedTime = 0
bool	m_FadeIn = false
bool	m_FadeOut = false
const float	FADE_TIME = 3
const float	R_TARGET = 0.142
const float	G_TARGET = 0.15
const float	B_TARGET = 0.44
float	m_Value
float	m_Exposure
float	m_Intensity
bool	m_PulseActive
float	m_PulseProgress
ref array< float >	m_ChannelWeights = { 0, 0, 0, 0 }
ref array< float >	m_ColorMod = { 1, 1, 1, 1 }
bool	m_Stopping
bool	m_StopNext
float	m_FadeOutTimeTarget
float	m_FadingTimeElapsed
float	m_FadingProgress
float	m_ElapsedTime
float	m_Gauss
float	m_VignetteIntensity
float	m_OverlayFactor
ref array< float >	m_OverlayColor

Закрытые члены
void	SetBloodLossLevel (float level)
void	SetValuesOptics (out array< float > mask_array, out array< float > lens_array, float gauss=0.0)
void	SetValuesIronsights (out array< float > DOF_array)
void	SetFeverIntensity (float intensity)
void	SetHitIntensity (float intensity)
void	SetInitialLenseOffset (float offsetAngle, float offsetDistance=0.5)
void	SetEffectProgress (float progress)
void	SetRadialBlur (float power_x, float power_y, float offset_x, float offset_y, float pixel_scale=0.5)
void	SetEyeAccommodation (float value)

Закрытые данные
float	m_EffectPhase = 0
float	m_Magnitude = 0
float	m_MinMagnitude = 0.3
float	m_MaxMagnitude = 0.3
float	m_Frequency = 5
float	m_Stamina01
const float	VAL_FACTOR = 0.85
const float	EXPOSURE_MAX = 50
const float	INTENSITY_MULT = 6.0
const float	WAVE_PROGRESS_MIN = 0
const float	WAVE_PROGRESS_MAX = Math.PI
const float	WAVE_AMPLITUDE_COEF = 0.7
const float	WAVE_TILT = -0.12
const float	DISTORT_MIN = 0
const float	DISTORT_MAX = -0.8
float	m_ProgressAngle
float	m_CurveValue
float	m_CurveValueClamped
float	m_LenseOffsetAngle
float	m_LenseOffsetDist

Закрытые статические данные
static const int	NV_NO_BATTERY = 0
static const int	NV_DEFAULT_OPTICS = 1
static const int	NV_DEFAULT_GLASSES = 2
static const int	NV_PUMPKIN = 3
static const int	NV_TRANSITIVE = 4
static const int	NV_DAYTIME_OPTICS = 5

Подробное описание

base, not to be used directly, would lead to layering collisions!

Методы

FadeColourMult() [1/2]

float FadeColourMult ( float x, float y, float deltaT )

inlineprotected

    {
        float output;
        output = Math.Lerp( x, y, deltaT );
        Easing.EaseInOutSine( output );
        return output;
    }

Перекрестные ссылки Easing::EaseInOutSine(), Math::Lerp(), x и y.

FadeColourMult() [2/2]

float FadeColourMult ( float x, float y, float deltaT )

inlineprotected

    {
        float output;
        output = Math.Lerp( x, y, deltaT );
        Easing.EaseInOutSine( output );
        return output;
    }

Перекрестные ссылки Easing::EaseInOutSine(), Math::Lerp(), x и y.

FadeOutEffect()

void FadeOutEffect ( float targetTime )

inlineprotected

    {
        m_Stopping = true;
        m_FadeOutTimeTarget = targetTime;
        m_FadingTimeElapsed = 0.0;
    }

OnStart() [1/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart();
        
        SetTargetValueFloat(PPEExceptions.EXPOSURE,PPEExposureNative.PARAM_INTENSITY,false,-100.0,PPEExposureNative.L_0_BURLAP,PPOperators.SET);
        SetTargetValueFloat(PPEExceptions.EYEACCOM,PPEEyeAccomodationNative.PARAM_INTENSITY,false,0.0,PPEEyeAccomodationNative.L_0_BURLAP,PPOperators.SET);
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_VIGNETTE,false,2.0,PPEGlow.L_25_BURLAP,PPOperators.SET);
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_VIGNETTECOLOR,{0.0,0.0,0.0,0.0},PPEGlow.L_26_BURLAP,PPOperators.LOWEST);
        
        if (GetGame() && GetGame().GetMission() && GetGame().GetMission().GetEffectWidgets())
        {
            GetGame().GetMission().GetEffectWidgets().AddSuspendRequest(EffectWidgetSuspends.BURLAPSACK);//these should probably be elsewhere, PPEs are mission independent
        }
    }

Перекрестные ссылки GetGame(), PPEExposureNative::L_0_BURLAP, PPEEyeAccomodationNative::L_0_BURLAP, PPEGlow::L_25_BURLAP, PPEGlow::L_26_BURLAP, PPEExposureNative::PARAM_INTENSITY, PPEEyeAccomodationNative::PARAM_INTENSITY, PPEGlow::PARAM_VIGNETTE, PPEGlow::PARAM_VIGNETTECOLOR, SetTargetValueColor() и SetTargetValueFloat().

OnStart() [2/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart();
        
        SetNVMode(Param1<int>.Cast(par).param1);
    }

OnStart() [3/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart( par );
        
        m_AccumulatedTime = 0;
        
        m_FadeIn = true;
        m_FadeOut = false;
        
        SetTargetValueFloat(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_SHARPNESS,false,10.0,PPEFilmGrain.L_1_TOXIC_TINT,PPOperators.HIGHEST);
        SetTargetValueFloat(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_GRAINSIZE,false,1.0,PPEFilmGrain.L_2_TOXIC_TINT,PPOperators.LOWEST);
    }

Перекрестные ссылки PPEFilmGrain::L_1_TOXIC_TINT, PPEFilmGrain::L_2_TOXIC_TINT, PPEFilmGrain::PARAM_GRAINSIZE, PPEFilmGrain::PARAM_SHARPNESS и SetTargetValueFloat().

OnStart() [4/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart();
        
        m_Value = Param1<float>.Cast(par).param1;
        //Print("PPERequester_DeathDarkening | level: " + m_Value);
        m_Value = Easing.EaseInCubic(m_Value);
        m_Value = Math.Lerp(0,-10,m_Value);
        //Print("PPERequester_DeathDarkening | value: " + value);
        
        SetTargetValueFloat(PPEExceptions.EXPOSURE,PPEExposureNative.PARAM_INTENSITY,false,m_Value,PPEExposureNative.L_0_DEATH,PPOperators.SET);
    }

Перекрестные ссылки Easing::EaseInCubic(), PPEExposureNative::L_0_DEATH, Math::Lerp(), m_Value, PPEExposureNative::PARAM_INTENSITY и SetTargetValueFloat().

OnStart() [5/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart(par);
        
        m_EffectPhase = 0;
        m_Magnitude = 0;
    }

OnStart() [6/16]

void OnStart ( Param par = null )

inlineprotected

    {
        if (!m_IsRunning)
        {
            if (GetGame().GetMission() && GetGame().GetMission().GetEffectWidgets())
                GetGame().GetMission().GetEffectWidgets().AddActiveEffects({EffectWidgetsTypes.COVER_FLASHBANG});
        }
        
        super.OnStart();
    }

Перекрестные ссылки GetGame() и m_IsRunning.

OnStart() [7/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart();
        
        SetTargetValueFloat(PostProcessEffectType.GodRays,PPEGodRays.PARAM_INTENSITY,true,0,PPEGodRays.L_0_GLASSES,PPOperators.LOWEST);
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{0.4,0.4,0.4,0.0},PPEGlow.L_23_GLASSES,PPOperators.SUBSTRACT);
    }

Перекрестные ссылки PPEGodRays::L_0_GLASSES, PPEGlow::L_23_GLASSES, PPEGlow::PARAM_COLORIZATIONCOLOR, PPEGodRays::PARAM_INTENSITY, SetTargetValueColor() и SetTargetValueFloat().

OnStart() [8/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart();
        
        SetTargetValueFloat(PostProcessEffectType.GodRays,PPEGodRays.PARAM_INTENSITY,true,0,PPEGodRays.L_0_GLASSES,PPOperators.LOWEST);
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{0.2,0.0,0.2,0.0},PPEGlow.L_23_GLASSES,PPOperators.SUBSTRACT);
    }

Перекрестные ссылки PPEGodRays::L_0_GLASSES, PPEGlow::L_23_GLASSES, PPEGlow::PARAM_COLORIZATIONCOLOR, PPEGodRays::PARAM_INTENSITY, SetTargetValueColor() и SetTargetValueFloat().

OnStart() [9/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart();
        
        SetTargetValueFloat(PostProcessEffectType.GodRays,PPEGodRays.PARAM_INTENSITY,true,0,PPEGodRays.L_0_GLASSES,PPOperators.LOWEST);
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{0.3,0.3,0.1,0.0},PPEGlow.L_23_GLASSES,PPOperators.SUBSTRACT);
    }

Перекрестные ссылки PPEGodRays::L_0_GLASSES, PPEGlow::L_23_GLASSES, PPEGlow::PARAM_COLORIZATIONCOLOR, PPEGodRays::PARAM_INTENSITY, SetTargetValueColor() и SetTargetValueFloat().

OnStart() [10/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart();
        
        SetTargetValueFloat(PostProcessEffectType.GodRays,PPEGodRays.PARAM_INTENSITY,true,0,PPEGodRays.L_0_GLASSES,PPOperators.LOWEST);
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{0.7,0.7,0.7,0.0},PPEGlow.L_23_GLASSES,PPOperators.SUBSTRACT);
    }

Перекрестные ссылки PPEGodRays::L_0_GLASSES, PPEGlow::L_23_GLASSES, PPEGlow::PARAM_COLORIZATIONCOLOR, PPEGodRays::PARAM_INTENSITY, SetTargetValueColor() и SetTargetValueFloat().

OnStart() [11/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart(par);
        
        m_Stopping = false;
        m_StopNext = false;
        m_ElapsedTime = 0.0;
        m_FadingTimeElapsed = 0.0;
        m_FadingProgress = 0.0;
        
        //following changes only performed once, on start
        //noise
        float nScaleX = 0.05; //inverse scaling!
        float nScaleY = 0.05; //inverse scaling!
        //ghosts
        float gOffsetX = 30;
        float gOffsetY = 13;
        float gScaleX = 1;  //inverse scaling!
        float gScaleY = 1;  //inverse scaling!
        //color modulation
        m_ColorMod[0] = 0.8;
        m_ColorMod[1] = 0.8;
        m_ColorMod[2] = 0.8;
        m_ColorMod[3] = 0.85;
        
        SetTargetValueFloat(PostProcessEffectType.Ghost,PPEGhost.PARAM_NOISE_SCALE_X,false, nScaleX,PPEGhost.L_4_HMP,PPOperators.LOWEST);
        SetTargetValueFloat(PostProcessEffectType.Ghost,PPEGhost.PARAM_NOISE_SCALE_Y,false, nScaleY,PPEGhost.L_5_HMP,PPOperators.LOWEST);
        SetTargetValueFloat(PostProcessEffectType.Ghost,PPEGhost.PARAM_GHOST_OFFSET_X,false, gOffsetX,PPEGhost.L_6_HMP,PPOperators.ADD);
        SetTargetValueFloat(PostProcessEffectType.Ghost,PPEGhost.PARAM_GHOST_OFFSET_Y,false, gOffsetY,PPEGhost.L_7_HMP,PPOperators.ADD);
        SetTargetValueFloat(PostProcessEffectType.Ghost,PPEGhost.PARAM_GHOST_SCALE_X,false, gScaleX,PPEGhost.L_8_HMP,PPOperators.LOWEST);
        SetTargetValueFloat(PostProcessEffectType.Ghost,PPEGhost.PARAM_GHOST_SCALE_Y,false, gScaleY,PPEGhost.L_9_HMP,PPOperators.LOWEST);
        SetTargetValueColor(PostProcessEffectType.Ghost,PPEGhost.PARAM_GHOST_COLOR_MOD,m_ColorMod,PPEGhost.L_1_HMP,PPOperators.SET);
    }

Перекрестные ссылки PPEGhost::L_1_HMP, PPEGhost::L_4_HMP, PPEGhost::L_5_HMP, PPEGhost::L_6_HMP, PPEGhost::L_7_HMP, PPEGhost::L_8_HMP, PPEGhost::L_9_HMP, PPEGhost::PARAM_GHOST_COLOR_MOD, PPEGhost::PARAM_GHOST_OFFSET_X, PPEGhost::PARAM_GHOST_OFFSET_Y, PPEGhost::PARAM_GHOST_SCALE_X, PPEGhost::PARAM_GHOST_SCALE_Y, PPEGhost::PARAM_NOISE_SCALE_X, PPEGhost::PARAM_NOISE_SCALE_Y, SetTargetValueColor() и SetTargetValueFloat().

OnStart() [12/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart();
        SetTargetValueFloat(PostProcessEffectType.GaussFilter,PPEGaussFilter.PARAM_INTENSITY,false,0.5,PPEGaussFilter.L_0_INV,PPOperators.SET); //PPOperators.OVERRIDE?
    }

Перекрестные ссылки PPEGaussFilter::L_0_INV, PPEGaussFilter::PARAM_INTENSITY и SetTargetValueFloat().

OnStart() [13/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart();
        
        m_Gauss = Param3<float,float,float>.Cast(par).param1;
        m_VignetteIntensity = Param3<float,float,float>.Cast(par).param2;
        m_OverlayFactor = Param3<float,float,float>.Cast(par).param3;
        
        m_OverlayColor = {0.0, 0.0, 0.0, 1.0};
        if (m_OverlayFactor > 0.0)
            m_OverlayColor = {0.1, 0.1, 0.1, 1.0};
        
        //blur
        SetTargetValueFloat(PostProcessEffectType.GaussFilter,PPEGaussFilter.PARAM_INTENSITY,true,m_Gauss,PPEGaussFilter.L_0_SHOCK,PPOperators.ADD_RELATIVE);
        //vignette
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_VIGNETTE,false,m_VignetteIntensity,PPEGlow.L_25_SHOCK,PPOperators.ADD);
        //SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_VIGNETTECOLOR,{0.25,0.25,0.25,0.0},PPEGlow.L_26_SHOCK,PPOperators.ADD_RELATIVE);
        //color overlay
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_OVERLAYFACTOR,true,m_OverlayFactor,PPEGlow.L_20_SHOCK,PPOperators.HIGHEST);
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_OVERLAYCOLOR,m_OverlayColor,PPEGlow.L_21_SHOCK,PPOperators.SET);
    }

Перекрестные ссылки PPEGaussFilter::L_0_SHOCK, PPEGlow::L_20_SHOCK, PPEGlow::L_21_SHOCK, PPEGlow::L_25_SHOCK, PPEGaussFilter::PARAM_INTENSITY, PPEGlow::PARAM_OVERLAYCOLOR, PPEGlow::PARAM_OVERLAYFACTOR, PPEGlow::PARAM_VIGNETTE, SetTargetValueColor() и SetTargetValueFloat().

OnStart() [14/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart( par );
        
        m_AccumulatedTime = 0;
        
        m_FadeIn = true;
        m_FadeOut = false;
        
        SetTargetValueFloat(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_SHARPNESS,false,10.0,PPEFilmGrain.L_1_TOXIC_TINT,PPOperators.HIGHEST);
        SetTargetValueFloat(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_GRAINSIZE,false,1.0,PPEFilmGrain.L_2_TOXIC_TINT,PPOperators.LOWEST);
    }

Перекрестные ссылки PPEFilmGrain::L_1_TOXIC_TINT, PPEFilmGrain::L_2_TOXIC_TINT, PPEFilmGrain::PARAM_GRAINSIZE, PPEFilmGrain::PARAM_SHARPNESS и SetTargetValueFloat().

OnStart() [15/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart();
        
        m_Intensity = Param1<float>.Cast(par).param1;
        
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_VIGNETTE,false,m_Intensity,PPEGlow.L_25_TUNNEL,PPOperators.HIGHEST);
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_VIGNETTECOLOR,{0.0,0.0,0.0,0.0},PPEGlow.L_26_TUNNEL,PPOperators.LOWEST);
    }

Перекрестные ссылки PPEGlow::L_25_TUNNEL, PPEGlow::L_26_TUNNEL, PPEGlow::PARAM_VIGNETTE, PPEGlow::PARAM_VIGNETTECOLOR, SetTargetValueColor() и SetTargetValueFloat().

OnStart() [16/16]

void OnStart ( Param par = null )

inlineprotected

    {
        super.OnStart();
        
        m_Intensity = Param1<float>.Cast(par).param1;
        
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_VIGNETTE,false,m_Intensity,PPEGlow.L_25_UNCON,PPOperators.ADD);
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_VIGNETTECOLOR,{0.0,0.0,0.0,0.0},PPEGlow.L_26_UNCON,PPOperators.LOWEST);
    }

Перекрестные ссылки PPEGlow::L_25_UNCON, PPEGlow::L_26_UNCON, PPEGlow::PARAM_VIGNETTE, PPEGlow::PARAM_VIGNETTECOLOR, SetTargetValueColor() и SetTargetValueFloat().

OnStop() [1/6]

void OnStop ( Param par = null )

inlineprotected

    {
        super.OnStop();
        
        if (GetGame() && GetGame().GetMission() && GetGame().GetMission().GetEffectWidgets())
        {
            GetGame().GetMission().GetEffectWidgets().RemoveSuspendRequest(EffectWidgetSuspends.BURLAPSACK);//these should probably be elsewhere, PPEs are mission independent
        }
    }

Перекрестные ссылки GetGame().

OnStop() [2/6]

void OnStop ( Param par = null )

inlineprotected

    {
        super.OnStop(par);
        
        if ( !GetGame() )
            return;
        
        GetGame().ResetPPMask();
        //material parameter values reset by default on stop
    }

Перекрестные ссылки GetGame().

OnStop() [3/6]

void OnStop ( Param par = null )

inlineprotected

    {
        super.OnStop(par);
    }

OnStop() [4/6]

override void OnStop ( Param par = null )

inlineprotected

    {
        m_FadeIn = false;
        m_FadeOut = false;
        Param1<bool> p;
        
        if (par && Class.CastTo(p,par))
            m_FadeOut = p.param1;
        
        m_AccumulatedTime = 0;
        
        super.OnStop(par);
    }

Перекрестные ссылки Class::CastTo().

OnStop() [5/6]

void OnStop ( Param par = null )

inlineprotected

    {
        super.OnStop();
        
        m_Intensity = 0.0;
        m_Exposure = 0.0;
        
        if (GetGame().GetMission() && GetGame().GetMission().GetEffectWidgets())
            GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.COVER_FLASHBANG});
    }

Перекрестные ссылки GetGame().

OnStop() [6/6]

override void OnStop ( Param par = null )

inlineprotected

    {
        m_FadeIn = false;
        m_FadeOut = false;
        Param1<bool> p;
        
        if (par && Class.CastTo(p,par))
            m_FadeOut = p.param1;
        
        m_AccumulatedTime = 0;
        
        super.OnStop(par);
    }

Перекрестные ссылки Class::CastTo().

OnUpdate() [1/5]

void OnUpdate ( float delta )

inlineprotected

    {
        super.OnUpdate( delta );
        
        if ( m_FadeIn && m_AccumulatedTime <= FADE_TIME )
        {
            m_AccumulatedTime += delta;
        
            m_StartRGB[0] = 1 - FadeColourMult( 0, 1, m_AccumulatedTime / FADE_TIME ) * R_TARGET;
            m_StartRGB[1] = 1 - FadeColourMult( 0, 1, m_AccumulatedTime / FADE_TIME ) * G_TARGET;
            m_StartRGB[2] = 1 - FadeColourMult( 0, 1, m_AccumulatedTime / FADE_TIME ) * B_TARGET;
            
            SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{m_StartRGB[0], m_StartRGB[1], m_StartRGB[2], 0.0},PPEGlow.L_23_TOXIC_TINT,PPOperators.MULTIPLICATIVE);
        }
        
        if ( m_FadeOut )
        {
            if (m_AccumulatedTime <= FADE_TIME)
            {
                m_AccumulatedTime += delta;
            
                m_StartRGB[0] = ( 1 - R_TARGET ) + FadeColourMult( 0, R_TARGET, m_AccumulatedTime / FADE_TIME );
                m_StartRGB[1] = ( 1 - G_TARGET ) + FadeColourMult( 0, G_TARGET, m_AccumulatedTime / FADE_TIME );
                m_StartRGB[2] = ( 1 - B_TARGET ) + FadeColourMult( 0, B_TARGET, m_AccumulatedTime / FADE_TIME );
                
                SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{m_StartRGB[0], m_StartRGB[1], m_StartRGB[2], 0.0},PPEGlow.L_23_TOXIC_TINT,PPOperators.MULTIPLICATIVE);
            }
            else
            {
                Stop(); //proper termination after a fadeout
            }
        }
    }

Перекрестные ссылки PPEGlow::L_23_TOXIC_TINT, PPEGlow::PARAM_COLORIZATIONCOLOR, SetTargetValueColor() и Stop().

OnUpdate() [2/5]

void OnUpdate ( float delta )

inlineprotected

    {           
        super.OnUpdate(delta);
        
        if (!m_IsRunning)
            return;
        
        m_EffectPhase += delta * m_Frequency / (m_Stamina01 + 1);   // Start with lower frequency and increase it as it gets closer to danger
        
        float currentVal = (Math.Sin(m_EffectPhase) +1)/2;                          // Makes current val oscillate between 0 and 1 (normlization)
        currentVal = Easing.EaseInExpo(currentVal);                                 // Ease it to tweak the effect
        currentVal *= currentVal * m_MaxMagnitude;                                  // Scale the normalized value to make it proportional to the Max Magnitude
        currentVal += m_MinMagnitude;
        m_Magnitude = Math.Lerp(m_Magnitude, currentVal, delta * m_Frequency);      // Learp to smooth the changes
        
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_VIGNETTE,true, m_Magnitude,PPEGodRays.L_0_GLASSES,PPOperators.ADD);
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_VIGNETTECOLOR,{0.0,0.025,0.04, 0.0},PPEGlow.L_23_GLASSES,PPOperators.ADD);
    }

Перекрестные ссылки Easing::EaseInExpo(), PPEGodRays::L_0_GLASSES, PPEGlow::L_23_GLASSES, Math::Lerp(), m_IsRunning, PPEGlow::PARAM_VIGNETTE, PPEGlow::PARAM_VIGNETTECOLOR, SetTargetValueColor(), SetTargetValueFloat() и Math::Sin().

OnUpdate() [3/5]

void OnUpdate ( float delta )

inlineprotected

    {
        super.OnUpdate(delta);
        
        if (GetGame() && GetGame().GetMission() && GetGame().GetMission().GetEffectWidgets())
        {
            Param1<float> par = new Param1<float>(1 - m_Intensity);
            GetGame().GetMission().GetEffectWidgets().UpdateWidgets(EffectWidgetsTypes.COVER_FLASHBANG,0,par,EffectWidgetHandles.FLASHBANG);
        }
    }

Перекрестные ссылки GetGame().

OnUpdate() [4/5]

void OnUpdate ( float delta )

inlineprotected

    {
        if (m_StopNext)
        {
            if (m_IsRunning)
                Stop();
            return;
        }
        
        ProcessSimulation(delta);
        
        super.OnUpdate(delta);
        
        SetRequesterUpdating(true);
    }

Перекрестные ссылки m_IsRunning, SetRequesterUpdating() и Stop().

OnUpdate() [5/5]

void OnUpdate ( float delta )

inlineprotected

    {
        super.OnUpdate( delta );
        
        if ( m_FadeIn && m_AccumulatedTime <= FADE_TIME )
        {
            m_AccumulatedTime += delta;
        
            m_StartRGB[0] = 1 - FadeColourMult( 0, 1, m_AccumulatedTime / FADE_TIME ) * R_TARGET;
            m_StartRGB[1] = 1 - FadeColourMult( 0, 1, m_AccumulatedTime / FADE_TIME ) * G_TARGET;
            m_StartRGB[2] = 1 - FadeColourMult( 0, 1, m_AccumulatedTime / FADE_TIME ) * B_TARGET;
            
            SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{m_StartRGB[0], m_StartRGB[1], m_StartRGB[2], 0.0},PPEGlow.L_23_TOXIC_TINT,PPOperators.MULTIPLICATIVE);
        }
        
        if ( m_FadeOut )
        {
            if (m_AccumulatedTime <= FADE_TIME)
            {
                m_AccumulatedTime += delta;
            
                m_StartRGB[0] = ( 1 - R_TARGET ) + FadeColourMult( 0, R_TARGET, m_AccumulatedTime / FADE_TIME );
                m_StartRGB[1] = ( 1 - G_TARGET ) + FadeColourMult( 0, G_TARGET, m_AccumulatedTime / FADE_TIME );
                m_StartRGB[2] = ( 1 - B_TARGET ) + FadeColourMult( 0, B_TARGET, m_AccumulatedTime / FADE_TIME );
                
                SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{m_StartRGB[0], m_StartRGB[1], m_StartRGB[2], 0.0},PPEGlow.L_23_TOXIC_TINT,PPOperators.MULTIPLICATIVE);
            }
            else
            {
                Stop(); //proper termination after a fadeout
            }
        }
    }

Перекрестные ссылки PPEGlow::L_23_TOXIC_TINT, PPEGlow::PARAM_COLORIZATIONCOLOR, SetTargetValueColor() и Stop().

ProcessFading()

void ProcessFading ( float delta )

inlineprotected

    {
        m_FadingTimeElapsed += delta;
        m_FadingProgress = m_FadingTimeElapsed/m_FadeOutTimeTarget;
        
        m_StopNext = m_FadingProgress >= 1.0;
    }

ProcessSimulation()

void ProcessSimulation ( float delta )

inlineprotected

    {
        if (m_Stopping)
            ProcessFading(delta);
        
        if (m_PulseActive)
        {
            //channel weights
            float time = m_ElapsedTime * 0.65;
            SampleChannels(time);
            ReSampleChannels(time);
            
            //noise
            float nOffsetX = (Math.Sin( time * 0.29 ) * 0.5 + 0.5) * 0.3;
            float nOffsetY = (Math.Cos( time * 0.17 ) * 0.5 + 0.5) * 0.3;
            
            //channel remapping
            float animLo = (Math.Sin( time ) * 0.5 + 0.5) * 1;
            float animHi = (Math.Sin( time ) * 0.5 + 0.5) * 1;
            float rmpLoAll = Math.Lerp(0.1,0.3,animLo);
            float rmpHiAll = Math.Lerp(0.9,1.2,animHi);
            
            SetTargetValueColor(PostProcessEffectType.Ghost,PPEGhost.PARAM_NOISE_CHANNEL_WEIGHT,m_ChannelWeights,PPEGhost.L_1_HMP,PPOperators.SET);
            SetTargetValueFloat(PostProcessEffectType.Ghost,PPEGhost.PARAM_NOISE_OFFSET_X,false, nOffsetX,PPEGhost.L_2_HMP,PPOperators.ADD);
            SetTargetValueFloat(PostProcessEffectType.Ghost,PPEGhost.PARAM_NOISE_OFFSET_Y,false, nOffsetY,PPEGhost.L_3_HMP,PPOperators.ADD);
            SetTargetValueColor(PostProcessEffectType.Ghost,PPEGhost.PARAM_NOISE_REMAP_LO,{rmpLoAll,rmpLoAll,rmpLoAll,rmpLoAll},PPEGhost.L_1_HMP,PPOperators.SET);
            SetTargetValueColor(PostProcessEffectType.Ghost,PPEGhost.PARAM_NOISE_REMAP_HI,{rmpHiAll,rmpHiAll,rmpHiAll,rmpHiAll},PPEGhost.L_1_HMP,PPOperators.SET);
            
            m_PulseActive = m_PulseProgress < 1.0;
        }
        
        m_ElapsedTime += delta;
    }

Перекрестные ссылки Math::Cos(), PPEGhost::L_1_HMP, PPEGhost::L_2_HMP, PPEGhost::L_3_HMP, Math::Lerp(), PPEGhost::PARAM_NOISE_CHANNEL_WEIGHT, PPEGhost::PARAM_NOISE_OFFSET_X, PPEGhost::PARAM_NOISE_OFFSET_Y, PPEGhost::PARAM_NOISE_REMAP_HI, PPEGhost::PARAM_NOISE_REMAP_LO, SetTargetValueColor(), SetTargetValueFloat() и Math::Sin().

ReSampleChannels()

void ReSampleChannels ( float time )

inlineprotected

    {
        float rampingCoef = 1.1;
        float w = Math.Clamp((Math.Sin(m_PulseProgress * Math.PI) * rampingCoef),0,1);
        w = Math.Lerp(0,w,1 - m_FadingProgress);
        
        for (int i = 0; i < 4; ++i)
            m_ChannelWeights[i] = w * m_ChannelWeights[i];
    }

Перекрестные ссылки Math::Clamp(), Math::Lerp(), Math::PI и Math::Sin().

SampleChannels()

void SampleChannels ( float time )

inlineprotected

    {
        float offset;
        // luckily 4 channels * 90 fit into 360 nicely, so no need to distribute weights other way
        for (int i = 0; i < 4; ++i)
        {
            offset = i * Math.PI_HALF;
            m_ChannelWeights[i] = Math.Sin( time + offset );
        }
    }

Перекрестные ссылки Math::PI_HALF и Math::Sin().

SetBloodLossLevel()

void SetBloodLossLevel ( float level )

inlineprivate

    {
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_SATURATION,true,level,PPEGlow.L_22_BLOODLOSS,PPOperators.SET);
    }

Перекрестные ссылки PPEGlow::L_22_BLOODLOSS, PPEGlow::PARAM_SATURATION и SetTargetValueFloat().

SetEffectProgress()

void SetEffectProgress ( float progress )

inlineprivate

    {
        m_ProgressAngle = Math.Lerp(WAVE_PROGRESS_MIN,WAVE_PROGRESS_MAX,progress);
        m_CurveValue = (1 / WAVE_TILT) * (Math.Atan((WAVE_TILT * Math.Sin(m_ProgressAngle)) / (1 - WAVE_TILT * Math.Cos(m_ProgressAngle)))) * WAVE_AMPLITUDE_COEF;
        m_CurveValueClamped = Math.Clamp(m_CurveValue,-1,1);
        
        float distort = Math.Lerp(DISTORT_MIN,DISTORT_MAX,m_CurveValueClamped);
        float centerX = Math.Lerp(0,m_LenseOffsetDist,Math.Sin(m_ProgressAngle + m_LenseOffsetAngle));
        float centerY = Math.Lerp(0,m_LenseOffsetDist,Math.Cos(m_ProgressAngle + m_LenseOffsetAngle));
        float chromAbb = Math.AbsFloat(m_CurveValueClamped); //scale
        
        float chromShiftR = 0.1;
        float chromShiftG = 0;
        float chromShiftB = 0.75;
        
        float alpha01 =  Math.Sin( -Math.PI_HALF +  7 *  m_ProgressAngle) * 0.5 + 0.5;
        vector colabA = "-1 -1 -0.85";
        vector colabB = "0 0 0";    
        vector absim = vector.Lerp(colabA, colabB, alpha01);
        
        array<float> color_mod = {absim[0], absim[1], absim[2], 1.0};
        
        vector coloverA = "0 0 0";
        vector coloverB = "0.25 0.9 0.1";   
        vector oversim = vector.Lerp(coloverA, coloverB, m_CurveValueClamped);
        
        array<float> color_overlay = {oversim[0], oversim[1], oversim[2], 0.5};
        
        SetTargetValueFloat(PostProcessEffectType.Distort,PPEDistort.PARAM_DISTORT,false, distort,PPEDistort.L_0_HMP,PPOperators.ADD);
        SetTargetValueFloat(PostProcessEffectType.Distort,PPEDistort.PARAM_CENTERX,false, centerX,PPEDistort.L_1_HMP,PPOperators.ADD);
        SetTargetValueFloat(PostProcessEffectType.Distort,PPEDistort.PARAM_CENTERY,false, centerY,PPEDistort.L_2_HMP,PPOperators.ADD);
        SetTargetValueFloat(PostProcessEffectType.Distort,PPEDistort.PARAM_CHROM_ABB,true, chromAbb,PPEDistort.L_3_HMP,PPOperators.ADD);
        SetTargetValueFloat(PostProcessEffectType.Distort,PPEDistort.PARAM_CHROM_ABB_SHIFTR,true, chromShiftR,PPEDistort.L_4_HMP,PPOperators.SET);
        SetTargetValueFloat(PostProcessEffectType.Distort,PPEDistort.PARAM_CHROM_ABB_SHIFTG,true, chromShiftG,PPEDistort.L_5_HMP,PPOperators.SET);
        SetTargetValueFloat(PostProcessEffectType.Distort,PPEDistort.PARAM_CHROM_ABB_SHIFTB,true, chromShiftB,PPEDistort.L_6_HMP,PPOperators.SET);
        SetTargetValueColor(PostProcessEffectType.Distort,PPEDistort.PARAM_CHROM_COLOR_MOD,color_mod,PPEDistort.L_7_HMP,PPOperators.ADD);
        
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,color_overlay,PPEGlow.L_23_HMP,PPOperators.ADD);
    }

Перекрестные ссылки Math::AbsFloat(), Math::Atan(), Math::Clamp(), Math::Cos(), PPEDistort::L_0_HMP, PPEDistort::L_1_HMP, PPEGlow::L_23_HMP, PPEDistort::L_2_HMP, PPEDistort::L_3_HMP, PPEDistort::L_4_HMP, PPEDistort::L_5_HMP, PPEDistort::L_6_HMP, PPEDistort::L_7_HMP, Math::Lerp(), vector::Lerp(), PPEDistort::PARAM_CENTERX, PPEDistort::PARAM_CENTERY, PPEDistort::PARAM_CHROM_ABB, PPEDistort::PARAM_CHROM_ABB_SHIFTB, PPEDistort::PARAM_CHROM_ABB_SHIFTG, PPEDistort::PARAM_CHROM_ABB_SHIFTR, PPEDistort::PARAM_CHROM_COLOR_MOD, PPEGlow::PARAM_COLORIZATIONCOLOR, PPEDistort::PARAM_DISTORT, Math::PI_HALF, SetTargetValueColor(), SetTargetValueFloat() и Math::Sin().

SetEyeAccommodation()

void SetEyeAccommodation ( float value )

inlineprivate

    {
        SetTargetValueFloat(PPEExceptions.EYEACCOM,PPEEyeAccomodationNative.PARAM_INTENSITY,false,value,PPEEyeAccomodationNative.L_0_UNDERGROUND,PPOperators.SET);
    }

Перекрестные ссылки PPEEyeAccomodationNative::L_0_UNDERGROUND, PPEEyeAccomodationNative::PARAM_INTENSITY и SetTargetValueFloat().

SetFeverIntensity()

void SetFeverIntensity ( float intensity )

inlineprivate

    {
        SetTargetValueFloat(PostProcessEffectType.GaussFilter,PPEGaussFilter.PARAM_INTENSITY,true,intensity,PPEGaussFilter.L_0_FEVER,PPOperators.ADD_RELATIVE);
    }

Перекрестные ссылки PPEGaussFilter::L_0_FEVER, PPEGaussFilter::PARAM_INTENSITY и SetTargetValueFloat().

SetFlashbangIntensity()

void SetFlashbangIntensity ( float intensity, float daytime_toggle )

inlineprotected

    {
        m_Intensity = intensity;
        array<float> overlay_color = {1.0, 1.0, 1.0, intensity};
        if (daytime_toggle <= 5.0)
        {
            m_Exposure = Math.Clamp(intensity * daytime_toggle,0.0,EXPOSURE_MAX);
        }
        else
        {
            m_Exposure = Easing.EaseInQuart(intensity);
            m_Exposure = Math.Clamp(EXPOSURE_MAX * m_Exposure,0.0,EXPOSURE_MAX);
        }
        overlay_color[3] = intensity;
        
        //blur
        SetTargetValueFloat(PostProcessEffectType.GaussFilter,PPEGaussFilter.PARAM_INTENSITY,true,intensity,PPEGaussFilter.L_0_FLASHBANG,PPOperators.ADD_RELATIVE);
        //overlay
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_OVERLAYFACTOR,true,intensity,PPEGlow.L_20_FLASHBANG,PPOperators.HIGHEST);
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_OVERLAYCOLOR,overlay_color,PPEGlow.L_21_FLASHBANG,PPOperators.SET);
        //exposure
        SetTargetValueFloat(PPEExceptions.EXPOSURE,PPEExposureNative.PARAM_INTENSITY,false,m_Exposure,PPEExposureNative.L_0_FLASHBANG,PPOperators.ADD);
    }

Перекрестные ссылки Math::Clamp(), Easing::EaseInQuart(), PPEExposureNative::L_0_FLASHBANG, PPEGaussFilter::L_0_FLASHBANG, PPEGlow::L_20_FLASHBANG, PPEGlow::L_21_FLASHBANG, PPEExposureNative::PARAM_INTENSITY, PPEGaussFilter::PARAM_INTENSITY, PPEGlow::PARAM_OVERLAYCOLOR, PPEGlow::PARAM_OVERLAYFACTOR, SetTargetValueColor() и SetTargetValueFloat().

SetHitIntensity()

void SetHitIntensity ( float intensity )

inlineprivate

    {
        //color overlay
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_OVERLAYFACTOR,true,0.05,PPEGlow.L_20_HIT,PPOperators.HIGHEST);
        SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_OVERLAYCOLOR,{intensity * INTENSITY_MULT, 0.0, 0.0, 1.0},PPEGlow.L_21_HIT,PPOperators.HIGHEST);
    }

Перекрестные ссылки PPEGlow::L_20_HIT, PPEGlow::L_21_HIT, PPEGlow::PARAM_OVERLAYCOLOR, PPEGlow::PARAM_OVERLAYFACTOR, SetTargetValueColor() и SetTargetValueFloat().

SetInitialLenseOffset()

void SetInitialLenseOffset ( float offsetAngle, float offsetDistance = 0.5 )

inlineprivate

    {
        m_LenseOffsetAngle = offsetAngle;
        m_LenseOffsetDist = Math.Clamp(offsetDistance,0,1);
    }

Перекрестные ссылки Math::Clamp().

SetNVMode()

void SetNVMode ( int mode )

inlineprotected

    {
        SetTargetValueFloat(PPEExceptions.EYEACCOM,PPEEyeAccomodationNative.PARAM_INTENSITY,false,1.0,PPEEyeAccomodationNative.L_0_NVG_GENERIC,PPOperators.SET);
        
        switch (mode)
        {
            case NV_NO_BATTERY: //battery off
                SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{0.0,0.0,0.0,0.0},PPEGlow.L_23_NVG,PPOperators.MULTIPLICATIVE);
                SetTargetValueFloatDefault(PPEExceptions.EXPOSURE,PPEExposureNative.PARAM_INTENSITY);
                SetTargetValueFloatDefault(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_SHARPNESS);
                SetTargetValueFloatDefault(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_GRAINSIZE);
                SetTargetValueFloat(PPEExceptions.NVLIGHTPARAMS,PPELightIntensityParamsNative.PARAM_LIGHT_MULT,false,1.0,PPELightIntensityParamsNative.L_0_NVG,PPOperators.HIGHEST);
                SetTargetValueFloat(PPEExceptions.NVLIGHTPARAMS,PPELightIntensityParamsNative.PARAM_NOISE_MULT,false,0.0,PPELightIntensityParamsNative.L_1_NVG,PPOperators.HIGHEST);
            break;
            
            case NV_DEFAULT_OPTICS: //NV optic on
                SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{0.0,1.0,0.0,0.0},PPEGlow.L_23_NVG,PPOperators.MULTIPLICATIVE);
                SetTargetValueFloat(PPEExceptions.EXPOSURE,PPEExposureNative.PARAM_INTENSITY,false,7.0 * m_UGExposureCoef,PPEExposureNative.L_0_NVG_OPTIC,PPOperators.ADD);
                SetTargetValueFloat(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_SHARPNESS,false,9.0,PPEFilmGrain.L_1_NVG,PPOperators.SET);
                SetTargetValueFloat(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_GRAINSIZE,false,1.0,PPEFilmGrain.L_2_NVG,PPOperators.SET);
                SetTargetValueFloat(PPEExceptions.NVLIGHTPARAMS,PPELightIntensityParamsNative.PARAM_LIGHT_MULT,false,3.0,PPELightIntensityParamsNative.L_0_NVG,PPOperators.HIGHEST);
                SetTargetValueFloat(PPEExceptions.NVLIGHTPARAMS,PPELightIntensityParamsNative.PARAM_NOISE_MULT,false,2.0,PPELightIntensityParamsNative.L_1_NVG,PPOperators.HIGHEST);
            break;
            
            case NV_DAYTIME_OPTICS: //NV optic in daytime mode
                SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{0.0,1.0,0.0,0.0},PPEGlow.L_23_NVG,PPOperators.MULTIPLICATIVE);
                SetTargetValueFloat(PPEExceptions.EXPOSURE,PPEExposureNative.PARAM_INTENSITY,false,2.0 * m_UGExposureCoef,PPEExposureNative.L_0_NVG_OPTIC,PPOperators.ADD);
                SetTargetValueFloat(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_SHARPNESS,false,9.0,PPEFilmGrain.L_1_NVG,PPOperators.SET);
                SetTargetValueFloat(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_GRAINSIZE,false,1.0,PPEFilmGrain.L_2_NVG,PPOperators.SET);
                SetTargetValueFloat(PPEExceptions.NVLIGHTPARAMS,PPELightIntensityParamsNative.PARAM_LIGHT_MULT,false,3.0,PPELightIntensityParamsNative.L_0_NVG,PPOperators.HIGHEST);
                SetTargetValueFloat(PPEExceptions.NVLIGHTPARAMS,PPELightIntensityParamsNative.PARAM_NOISE_MULT,false,1.0,PPELightIntensityParamsNative.L_1_NVG,PPOperators.HIGHEST);
            break;
            
            case NV_DEFAULT_GLASSES: //goggles on
                SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{0.0,1.0,0.0,0.0},PPEGlow.L_23_NVG,PPOperators.MULTIPLICATIVE);
                SetTargetValueFloat(PPEExceptions.EXPOSURE,PPEExposureNative.PARAM_INTENSITY,false,7.0 * m_UGExposureCoef,PPEExposureNative.L_0_NVG_GOGGLES,PPOperators.ADD);
                SetTargetValueFloat(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_SHARPNESS,false,10.0,PPEFilmGrain.L_1_NVG,PPOperators.SET);
                SetTargetValueFloat(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_GRAINSIZE,false,1.0,PPEFilmGrain.L_2_NVG,PPOperators.SET);
                SetTargetValueFloat(PPEExceptions.NVLIGHTPARAMS,PPELightIntensityParamsNative.PARAM_LIGHT_MULT,false,2.0,PPELightIntensityParamsNative.L_0_NVG,PPOperators.HIGHEST);
                SetTargetValueFloat(PPEExceptions.NVLIGHTPARAMS,PPELightIntensityParamsNative.PARAM_NOISE_MULT,false,1.0,PPELightIntensityParamsNative.L_1_NVG,PPOperators.HIGHEST);
            break;
            
            case NV_PUMPKIN: //pumpkin-o-vision
                SetTargetValueColor(PostProcessEffectType.Glow,PPEGlow.PARAM_COLORIZATIONCOLOR,{1.0,0.2,0.0,0.0},PPEGlow.L_23_NVG,PPOperators.MULTIPLICATIVE);
                SetTargetValueFloat(PPEExceptions.EXPOSURE,PPEExposureNative.PARAM_INTENSITY,false,5.5 * m_UGExposureCoef,PPEExposureNative.L_0_NVG_GOGGLES,PPOperators.ADD);
                SetTargetValueFloatDefault(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_SHARPNESS);
                SetTargetValueFloatDefault(PostProcessEffectType.FilmGrain,PPEFilmGrain.PARAM_GRAINSIZE);
                SetTargetValueFloat(PPEExceptions.NVLIGHTPARAMS,PPELightIntensityParamsNative.PARAM_LIGHT_MULT,false,1.0,PPELightIntensityParamsNative.L_0_NVG,PPOperators.HIGHEST);
                SetTargetValueFloat(PPEExceptions.NVLIGHTPARAMS,PPELightIntensityParamsNative.PARAM_NOISE_MULT,false,0.0,PPELightIntensityParamsNative.L_1_NVG,PPOperators.HIGHEST);
            break;
            
            case NV_TRANSITIVE: //camera transition
                //SetTargetValueFloat(PPEExceptions.EXPOSURE,PPEExposureNative.PARAM_INTENSITY,false,0,PPEExposureNative.L_0_NVG_OFF,PPOperators.SET);
                SetTargetValueFloatDefault(PPEExceptions.EXPOSURE,PPEExposureNative.PARAM_INTENSITY);
            break;
        }
        
        m_CurrentMode = mode;
    }

Перекрестные ссылки PPELightIntensityParamsNative::L_0_NVG, PPEEyeAccomodationNative::L_0_NVG_GENERIC, PPEExposureNative::L_0_NVG_GOGGLES, PPEExposureNative::L_0_NVG_OPTIC, PPELightIntensityParamsNative::L_1_NVG, PPEFilmGrain::L_1_NVG, PPEGlow::L_23_NVG, PPEFilmGrain::L_2_NVG, m_CurrentMode, NV_PUMPKIN, PPEGlow::PARAM_COLORIZATIONCOLOR, PPEFilmGrain::PARAM_GRAINSIZE, PPEExposureNative::PARAM_INTENSITY, PPEEyeAccomodationNative::PARAM_INTENSITY, PPELightIntensityParamsNative::PARAM_LIGHT_MULT, PPELightIntensityParamsNative::PARAM_NOISE_MULT, PPEFilmGrain::PARAM_SHARPNESS, SetTargetValueColor(), SetTargetValueFloat() и SetTargetValueFloatDefault().

SetPulseProgress()

void SetPulseProgress ( float progress )

inlineprotected

    {
        m_PulseActive = true;
        m_PulseProgress = progress;
    }

SetRadialBlur()

void SetRadialBlur ( float power_x, float power_y, float offset_x, float offset_y, float pixel_scale = 0.5 )

inlineprivate

    {
        SetTargetValueFloat(PostProcessEffectType.RadialBlur,PPERadialBlur.PARAM_POWERX,false,power_x, PPERadialBlur.L_0_PAIN_BLUR ,PPOperators.SET);
        SetTargetValueFloat(PostProcessEffectType.RadialBlur,PPERadialBlur.PARAM_POWERY,false,power_y, PPERadialBlur.L_0_PAIN_BLUR,PPOperators.SET);
        SetTargetValueFloat(PostProcessEffectType.RadialBlur,PPERadialBlur.PARAM_OFFSETX,false,offset_x, PPERadialBlur.L_0_PAIN_BLUR,PPOperators.SET);
        SetTargetValueFloat(PostProcessEffectType.RadialBlur,PPERadialBlur.PARAM_OFFSETY,false,offset_y, PPERadialBlur.L_0_PAIN_BLUR,PPOperators.SET);
        SetTargetValueFloat(PostProcessEffectType.RadialBlur,PPERadialBlur.PARAM_PIXELSCALE,false,pixel_scale,PPERadialBlur.L_0_PAIN_BLUR ,PPOperators.SET);
    }

Перекрестные ссылки PPERadialBlur::L_0_PAIN_BLUR, PPERadialBlur::PARAM_OFFSETX, PPERadialBlur::PARAM_OFFSETY, PPERadialBlur::PARAM_PIXELSCALE, PPERadialBlur::PARAM_POWERX, PPERadialBlur::PARAM_POWERY и SetTargetValueFloat().

SetStamina01()

void SetStamina01 ( float stamina01 )

inlineprotected

    {
        m_Stamina01 = stamina01;
    }

SetUndergroundExposureCoef()

void SetUndergroundExposureCoef ( float coef )

inlineprotected

    {
        m_UGExposureCoef = coef;
        
        if (m_IsRunning)
            SetNVMode(m_CurrentMode); //TODO: improve (oof...)
    }

Перекрестные ссылки m_CurrentMode и m_IsRunning.

SetValuesIronsights()

void SetValuesIronsights ( out array< float > DOF_array )

inlineprivate

    {
        //mask - no mask
        GetGame().ResetPPMask();
        
        //lens - no lens
        SetTargetValueFloatDefault(PostProcessEffectType.Glow,PPEGlow.PARAM_LENSDISTORT);
        SetTargetValueFloatDefault(PostProcessEffectType.Glow,PPEGlow.PARAM_MAXCHROMABBERATION);
        SetTargetValueFloatDefault(PostProcessEffectType.Glow,PPEGlow.PARAM_LENSCENTERX);
        SetTargetValueFloatDefault(PostProcessEffectType.Glow,PPEGlow.PARAM_LENSCENTERY);
        
        //DOF
        SetTargetValueBool(PPEExceptions.DOF,PPEDOF.PARAM_ENABLE,DOF_array[0],PPEDOF.L_0_ADS,PPOperators.SET);
        SetTargetValueFloat(PPEExceptions.DOF,PPEDOF.PARAM_FOCUS_DIST,false,DOF_array[1],PPEDOF.L_1_ADS,PPOperators.SET);
        SetTargetValueFloat(PPEExceptions.DOF,PPEDOF.PARAM_FOCUS_LEN,false,DOF_array[2],PPEDOF.L_2_ADS,PPOperators.SET);
        SetTargetValueFloat(PPEExceptions.DOF,PPEDOF.PARAM_FOCUS_LEN_NEAR,false,DOF_array[3],PPEDOF.L_3_ADS,PPOperators.SET);
        SetTargetValueFloat(PPEExceptions.DOF,PPEDOF.PARAM_BLUR,false,DOF_array[4],PPEDOF.L_4_ADS,PPOperators.SET);
        SetTargetValueFloat(PPEExceptions.DOF,PPEDOF.PARAM_FOCUS_DEPTH_OFFSET,false,DOF_array[5],PPEDOF.L_5_ADS,PPOperators.SET);
        
        //blur - no gauss blur (DOF bokeh only)
        SetTargetValueFloatDefault(PostProcessEffectType.GaussFilter,PPEGaussFilter.PARAM_INTENSITY);
    }

Перекрестные ссылки GetGame(), PPEDOF::L_0_ADS, PPEDOF::L_1_ADS, PPEDOF::L_2_ADS, PPEDOF::L_3_ADS, PPEDOF::L_4_ADS, PPEDOF::L_5_ADS, PPEDOF::PARAM_BLUR, PPEDOF::PARAM_ENABLE, PPEDOF::PARAM_FOCUS_DEPTH_OFFSET, PPEDOF::PARAM_FOCUS_DIST, PPEDOF::PARAM_FOCUS_LEN, PPEDOF::PARAM_FOCUS_LEN_NEAR, PPEGaussFilter::PARAM_INTENSITY, PPEGlow::PARAM_LENSCENTERX, PPEGlow::PARAM_LENSCENTERY, PPEGlow::PARAM_LENSDISTORT, PPEGlow::PARAM_MAXCHROMABBERATION, SetTargetValueBool(), SetTargetValueFloat() и SetTargetValueFloatDefault().

SetValuesOptics()

void SetValuesOptics ( out array< float > mask_array, out array< float > lens_array, float gauss = 0.0 )

inlineprivate

    {
        //mask
        GetGame().ResetPPMask();
        if (mask_array.Count() != 4)
        {
            mask_array = {0.0,0.0,0.0,0.0};
        }
        GetGame().AddPPMask(mask_array[0], mask_array[1], mask_array[2], mask_array[3]);
        
        //lens
        if (lens_array.Count() != 4)
        {
            lens_array = {0.0,0.0,0.0,0.0};
        }
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_LENSDISTORT,false,lens_array[0],PPEGlow.L_27_ADS,PPOperators.SET);
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_MAXCHROMABBERATION,false,lens_array[1],PPEGlow.L_28_ADS,PPOperators.SET);
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_LENSCENTERX,false,lens_array[2],PPEGlow.L_29_ADS,PPOperators.SET);
        SetTargetValueFloat(PostProcessEffectType.Glow,PPEGlow.PARAM_LENSCENTERY,false,lens_array[3],PPEGlow.L_30_ADS,PPOperators.SET);
        
        //DOF - no DOF in optics
        SetTargetValueBoolDefault(PPEExceptions.DOF,PPEDOF.PARAM_ENABLE);
        
        //blur
        SetTargetValueFloat(PostProcessEffectType.GaussFilter,PPEGaussFilter.PARAM_INTENSITY,false,gauss,PPEGaussFilter.L_0_ADS,PPOperators.ADD_RELATIVE);
    }

Перекрестные ссылки GetGame(), PPEGaussFilter::L_0_ADS, PPEGlow::L_27_ADS, PPEGlow::L_28_ADS, PPEGlow::L_29_ADS, PPEGlow::L_30_ADS, PPEDOF::PARAM_ENABLE, PPEGaussFilter::PARAM_INTENSITY, PPEGlow::PARAM_LENSCENTERX, PPEGlow::PARAM_LENSCENTERY, PPEGlow::PARAM_LENSDISTORT, PPEGlow::PARAM_MAXCHROMABBERATION, SetTargetValueBoolDefault() и SetTargetValueFloat().

Поля

B_TARGET

const float B_TARGET = 0.44

protected

DISTORT_MAX

const float DISTORT_MAX = -0.8

private

DISTORT_MIN

const float DISTORT_MIN = 0

private

EXPOSURE_MAX

const float EXPOSURE_MAX = 50

private

FADE_TIME

const float FADE_TIME = 3

protected

G_TARGET

const float G_TARGET = 0.15

protected

INTENSITY_MULT

const float INTENSITY_MULT = 6.0

private

m_AccumulatedTime

float m_AccumulatedTime = 0

protected

m_ChannelWeights

ref array<float> m_ChannelWeights = { 0, 0, 0, 0 }

protected

{ 0, 0, 0, 0 };

m_ColorMod

ref array<float> m_ColorMod = { 1, 1, 1, 1 }

protected

{ 1, 1, 1, 1 };

m_CurrentMode

int m_CurrentMode

protected

m_CurveValue

float m_CurveValue

private

m_CurveValueClamped

float m_CurveValueClamped

private

m_EffectPhase

float m_EffectPhase = 0

private

m_ElapsedTime

float m_ElapsedTime

protected

m_Exposure

float m_Exposure

protected

m_FadeIn

bool m_FadeIn = false

protected

m_FadeOut

bool m_FadeOut = false

protected

m_FadeOutTimeTarget

float m_FadeOutTimeTarget

protected

m_FadingProgress

float m_FadingProgress

protected

m_FadingTimeElapsed

float m_FadingTimeElapsed

protected

m_Frequency

float m_Frequency = 5

private

m_Gauss

float m_Gauss

protected

m_Intensity

float m_Intensity

protected

m_LenseOffsetAngle

float m_LenseOffsetAngle

private

m_LenseOffsetDist

float m_LenseOffsetDist

private

m_Magnitude

float m_Magnitude = 0

private

m_MaxMagnitude

float m_MaxMagnitude = 0.3

private

m_MinMagnitude

float m_MinMagnitude = 0.3

private

m_OverlayColor

ref array<float> m_OverlayColor

protected

m_OverlayFactor

float m_OverlayFactor

protected

m_ProgressAngle

float m_ProgressAngle

private

m_PulseActive

bool m_PulseActive

protected

m_PulseProgress

float m_PulseProgress

protected

m_Stamina01

float m_Stamina01

private

m_StartRGB

vector m_StartRGB = vector.Zero

protected

m_StopNext

bool m_StopNext

protected

m_Stopping

bool m_Stopping

protected

m_UGExposureCoef

float m_UGExposureCoef = 1.0

protected

m_Value

float m_Value

protected

m_VignetteIntensity

float m_VignetteIntensity

protected

NV_DAYTIME_OPTICS

const int NV_DAYTIME_OPTICS = 5

staticprivate

NV_DEFAULT_GLASSES

const int NV_DEFAULT_GLASSES = 2

staticprivate

NV_DEFAULT_OPTICS

const int NV_DEFAULT_OPTICS = 1

staticprivate

NV_NO_BATTERY

const int NV_NO_BATTERY = 0

staticprivate

NV_PUMPKIN

const int NV_PUMPKIN = 3

staticprivate

NV_TRANSITIVE

const int NV_TRANSITIVE = 4

staticprivate

R_TARGET

const float R_TARGET = 0.142

protected

VAL_FACTOR

const float VAL_FACTOR = 0.85

private

WAVE_AMPLITUDE_COEF

const float WAVE_AMPLITUDE_COEF = 0.7

private

WAVE_PROGRESS_MAX

const float WAVE_PROGRESS_MAX = Math.PI

private

WAVE_PROGRESS_MIN

const float WAVE_PROGRESS_MIN = 0

private

WAVE_TILT

const float WAVE_TILT = -0.12

private

---

Объявления и описания членов классов находятся в файлах:

• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERBloodLoss.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERCameraNV.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERContaminated.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERDeathDarkening.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERDrowningEffect.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERFlashbangEffects.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERHealthHit.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERHMP_LVL3.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERHMPGhosts.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERShockHit.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERSpooky.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERTunnel.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERUnconEffects.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERBurlapSack.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERCameraADS_Opt.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERFever.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERGlasses.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERInventoryBlur.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERPain.c
• D:/Ishodniki/scripts/3_Game/PPEManager/Requesters/PPERUndergroundAcco.c