BleedingDrop.c

См. документацию.

 
class BleedingIndicatorDropData
{
    protected ImageWidget   m_Widget;
    protected int           m_Severity;
    protected float         m_TimeTotal;
    protected float         m_ProgressBreakpointTime;
    protected float         m_ProgressFadingDuration; //remaining duration AFTER breakpoint
    protected float         m_ProgressBreakpoint;
    protected float         m_Duration;
    protected float         m_SpeedCoef;
    protected int           m_ScatterPx;
    protected float         m_SlideDistance;
    
    protected float         m_ColorAlphaStart;
    protected float         m_ColorAlphaEnd;
    protected float         m_ColorAlphaCurrent;
    
    protected float         m_ImageBaseSizeX;
    protected float         m_ImageBaseSizeY;
    protected float         m_ImageStartingSizeX; //adjusted by percentage
    protected float         m_ImageStartingSizeY; //adjusted by percentage
    protected float         m_ImageEndSizeX; //adjusted by percentage
    protected float         m_ImageEndSizeY; //adjusted by percentage
    protected float         m_ImageMaxSizeX;
    protected float         m_ImageMaxSizeY;
    protected float         m_ImageBaseRotation;
    protected bool          m_IsRunning;
    protected vector      m_BasePosition;
    protected int           m_ScreenSizeX;
    protected int           m_ScreenSizeY;
    protected float         m_PosX, m_PosY;
    protected float         m_StartSizeCoef;
    protected float         m_EndSizeCoef;
    protected float         m_RandomSizeMin;
    protected float         m_RandomSizeMax;
    
    //Written with relative positioning in mind
    void BleedingIndicatorDropData(ImageWidget image, int severity)
    {
        m_Widget = image;
        m_Severity = severity;
        m_TimeTotal = 0;
        m_IsRunning = false;
        
#ifdef DIAG_DEVELOPER
        if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues)
        {
            m_Duration = DbgBleedingIndicationStaticInfo.m_DbgDropDurationBase;
            m_ProgressBreakpointTime = m_Duration * DbgBleedingIndicationStaticInfo.m_DbgDropProgressTreshold;
            m_ProgressBreakpoint = DbgBleedingIndicationStaticInfo.m_DbgDropProgressTreshold;
            m_StartSizeCoef = DbgBleedingIndicationStaticInfo.m_DbgDropStartSize;
            m_EndSizeCoef = DbgBleedingIndicationStaticInfo.m_DbgDropEndSize;
            m_RandomSizeMin = DbgBleedingIndicationStaticInfo.m_DbgDropSizeVariationMin;
            m_RandomSizeMax = DbgBleedingIndicationStaticInfo.m_DbgDropSizeVariationMax;
            m_ScatterPx = DbgBleedingIndicationStaticInfo.m_DbgDropScatter;
            m_SlideDistance = DbgBleedingIndicationStaticInfo.m_DbgDropSlideDistance;
        }
        else
#endif
        {
            switch (m_Severity)
            {
                case BleedingIndicationConstants.INDICATOR_SEVERITY_LOW:
                {
                    m_Duration = BleedingIndicationConstants.DROP_DURATION_LOW;
                    m_StartSizeCoef = BleedingIndicationConstants.DROP_SIZE_START_LOW;
                    m_EndSizeCoef = BleedingIndicationConstants.DROP_SIZE_END_LOW;
                    m_RandomSizeMin = BleedingIndicationConstants.DROP_SIZE_VARIATION_MIN_LOW;
                    m_RandomSizeMax = BleedingIndicationConstants.DROP_SIZE_VARIATION_MAX_LOW;
                    m_ScatterPx = BleedingIndicationConstants.DROP_SCATTER_LOW;
                    m_SlideDistance = BleedingIndicationConstants.DROP_SLIDE_DISTANCE_LOW;
                    break;
                }
                case BleedingIndicationConstants.INDICATOR_SEVERITY_MEDIUM:
                {
                    m_Duration = BleedingIndicationConstants.DROP_DURATION_MEDIUM;
                    m_StartSizeCoef = BleedingIndicationConstants.DROP_SIZE_START_MEDIUM;
                    m_EndSizeCoef = BleedingIndicationConstants.DROP_SIZE_END_MEDIUM;
                    m_RandomSizeMin = BleedingIndicationConstants.DROP_SIZE_VARIATION_MIN_MEDIUM;
                    m_RandomSizeMax = BleedingIndicationConstants.DROP_SIZE_VARIATION_MAX_MEDIUM;
                    m_ScatterPx = BleedingIndicationConstants.DROP_SCATTER_MEDIUM;
                    m_SlideDistance = BleedingIndicationConstants.DROP_SLIDE_DISTANCE_MEDIUM;
                    break;
                }
                case BleedingIndicationConstants.INDICATOR_SEVERITY_HIGH:
                {
                    m_Duration = BleedingIndicationConstants.DROP_DURATION_HIGH;
                    m_StartSizeCoef = BleedingIndicationConstants.DROP_SIZE_START_HIGH;
                    m_EndSizeCoef = BleedingIndicationConstants.DROP_SIZE_END_HIGH;
                    m_RandomSizeMin = BleedingIndicationConstants.DROP_SIZE_VARIATION_MIN_HIGH;
                    m_RandomSizeMax = BleedingIndicationConstants.DROP_SIZE_VARIATION_MAX_HIGH;
                    m_ScatterPx = BleedingIndicationConstants.DROP_SCATTER_HIGH;
                    m_SlideDistance = BleedingIndicationConstants.DROP_SLIDE_DISTANCE_HIGH;
                    break;
                }
            }
            
            m_ProgressBreakpointTime = m_Duration * BleedingIndicationConstants.DROP_PROGRESS_THRESHOLD;
            m_ProgressBreakpoint = BleedingIndicationConstants.DROP_PROGRESS_THRESHOLD;
        }
        m_ProgressFadingDuration = Math.Max(0.0001, m_Duration - m_ProgressBreakpointTime);
        
        m_SpeedCoef = 1.0; //TODO ??
#ifdef DIAG_DEVELOPER
        if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues)
        {
            m_ColorAlphaStart = DbgBleedingIndicationStaticInfo.m_DbgDropColorAlphaStart / 255;
            m_ColorAlphaEnd = DbgBleedingIndicationStaticInfo.m_DbgDropColorAlphaEnd / 255;
        }
        else
#endif
        {
            m_ColorAlphaStart = BleedingIndicationConstants.DROP_COLOR_ALPHA_START / 255;
            m_ColorAlphaEnd = BleedingIndicationConstants.DROP_COLOR_ALPHA_END / 255;
        }
        InitImageScale();
        GetScreenSize(m_ScreenSizeX,m_ScreenSizeY);
        AdjustColorSaturation();
    }
    
    void ~BleedingIndicatorDropData()
    {
    }
    
    protected void InitImageScale()
    {
        m_Widget.GetSize(m_ImageBaseSizeX,m_ImageBaseSizeY);
        float randomScaleCoef =  Math.RandomFloatInclusive(m_RandomSizeMin,m_RandomSizeMax);
        
        m_ImageStartingSizeX = m_ImageBaseSizeX * m_StartSizeCoef * randomScaleCoef;
        m_ImageEndSizeX = m_ImageBaseSizeX * m_EndSizeCoef * randomScaleCoef;
        m_ImageStartingSizeY = m_ImageBaseSizeY * m_StartSizeCoef * randomScaleCoef;
        m_ImageEndSizeY = m_ImageBaseSizeY * m_EndSizeCoef * randomScaleCoef;
    }
    
    void ScatterPosition(vector pos)
    {
#ifdef DIAG_DEVELOPER
        if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues)
        {
            m_ScatterPx = DbgBleedingIndicationStaticInfo.m_DbgDropScatter;
        }
#endif
        float rndRadius = Math.RandomFloatInclusive(0.0,m_ScatterPx);
        float rndPos = Math.RandomFloatInclusive(0.0,Math.PI2);
        m_PosX = pos[0];
        m_PosX = m_PosX + rndRadius * Math.Sin(rndPos);
        
        m_PosY = pos[1];
        m_PosY = m_PosY + rndRadius * Math.Cos(rndPos);
    }
    
    void StartDrop()
    {
        m_TimeTotal = 0;
        
        ScatterPosition(m_BasePosition);
        m_Widget.SetPos(m_PosX,m_PosY);
#ifdef DIAG_DEVELOPER
        if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues && !DbgBleedingIndicationStaticInfo.m_DbgDropRotationRandom)
        {
            m_Widget.SetRotation(0,0,0);
        }
        else
#endif
        {
            m_Widget.SetRotation(0,0,Math.RandomFloatInclusive(0.0,360.0));
        }
        
        m_Widget.Show(true);
        m_IsRunning = true;
    }
    
    void StopDrop()
    {
        m_IsRunning = false;
        m_Widget.SetSize(m_ImageBaseSizeX,m_ImageBaseSizeY); //resets image size
        m_Widget.Show(false);
    }
    
    void SetBasePosition(vector pos)
    {
        m_BasePosition = pos;
        m_BasePosition[0] = m_BasePosition[0] - m_ScreenSizeX/2;
        m_BasePosition[1] = m_BasePosition[1] - m_ScreenSizeY/2;
    }
    
    bool IsRunning()
    {
        return m_IsRunning;
    }
    
    ImageWidget GetImage()
    {
        return m_Widget;
    }
    
    void AdjustColorSaturation()
    {
        //color adjustment
        float r = BleedingIndicationConstants.DROP_COLOR_RED;
        float g = BleedingIndicationConstants.DROP_COLOR_GREEN;
        float b = BleedingIndicationConstants.DROP_COLOR_BLUE;
        float desaturationEnd = BleedingIndicationConstants.DROP_COLOR_DESATURATIONEND;
#ifdef DIAG_DEVELOPER
        if (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues)
        {
            r = DbgBleedingIndicationStaticInfo.m_DbgDropColorRed;
            g = DbgBleedingIndicationStaticInfo.m_DbgDropColorGreen;
            b = DbgBleedingIndicationStaticInfo.m_DbgDropColorBlue;
            desaturationEnd = DbgBleedingIndicationStaticInfo.m_DbgDesaturationEnd;
        }
#endif
        
        //saturation adjustment
#ifdef DIAG_DEVELOPER
        if (!DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues || (DbgBleedingIndicationStaticInfo.m_DbgUseOverrideValues && DbgBleedingIndicationStaticInfo.m_DbgDropDesaturate) )
        {
#endif
            Param par = PPEManagerStatic.GetPPEManager().GetPostProcessCurrentValues(PostProcessEffectType.Glow,PPEGlow.PARAM_SATURATION);
            float saturationProgress = Param1<float>.Cast(par).param1;
            saturationProgress = Easing.EaseOutSine(saturationProgress);
            saturationProgress = Math.Lerp(desaturationEnd,1.0,saturationProgress);
            float lowest_channel = Math.Min(Math.Min(r,g),b);
            r = Math.Lerp(lowest_channel,r,saturationProgress);
            g = Math.Lerp(lowest_channel,g,saturationProgress);
            b = Math.Lerp(lowest_channel,b,saturationProgress);
#ifdef DIAG_DEVELOPER
        }
#endif
        
        int color = ARGB(0x00,r,g,b);
        m_Widget.SetColor(color);
    }
    
    void UpdateAlpha(float progress,float progressFade)
    {
        if (progress <= m_ProgressBreakpoint)
        {
            m_ColorAlphaCurrent = m_ColorAlphaStart;
        }
        else
        {
            m_ColorAlphaCurrent = Math.Lerp(m_ColorAlphaStart,m_ColorAlphaEnd,progressFade);
        }
        
        m_Widget.SetAlpha(m_ColorAlphaCurrent);
    }
    
    void UpdateTransform(float progress, float progressFade)
    {
        float breakProgress = Math.Clamp(Math.InverseLerp(0.0,m_ProgressBreakpoint,progress),0,1);
        float sizeX = Math.Lerp(m_ImageStartingSizeX,m_ImageEndSizeX,breakProgress);
        float sizeY = Math.Lerp(m_ImageStartingSizeY,m_ImageEndSizeY,breakProgress);
        m_Widget.SetSize(sizeX,sizeY);
        
        if (progress <= m_ProgressBreakpoint)
        {
            //do stuff before breakpoint
        }
        else
        {
            //do stuff after breakpoint
            float posYTemp = Math.Lerp(m_PosY,m_PosY + m_SlideDistance, progressFade);
            m_Widget.SetPos(m_PosX,posYTemp);
        }
    }
    
    void Update(float timeSlice)
    {
        if (m_IsRunning)
        {
            float progress, progressFade;
            progress = m_TimeTotal / m_Duration;
            progressFade = (m_TimeTotal - m_ProgressBreakpointTime) / m_ProgressFadingDuration;
            
            //alpha
            UpdateAlpha(progress,progressFade);
            //transform + scaling
            UpdateTransform(progress,progressFade);
            
            m_TimeTotal += (timeSlice * m_SpeedCoef);
            
            if (m_TimeTotal >= m_Duration)
            {
                //deletes this;
                StopDrop();
            }
        }
    }
}