RGBAFadeOnOffEffect.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DirectOutput.Cab.Toys.Layer;
using DirectOutput.Cab.Color;

namespace DirectOutput.FX.RGBAFX
{
    public class RGBAFadeOnOffEffect : RGBAEffectBase
    {
        private const int FadingRefreshIntervalMs = 30;

        private RetriggerBehaviourEnum _RetriggerBehaviour;

        public RetriggerBehaviourEnum RetriggerBehaviour
        {
            get { return _RetriggerBehaviour; }
            set { _RetriggerBehaviour = value; }
        }

        private FadeModeEnum _FadeMode = FadeModeEnum.DefinedToDefined;

        public FadeModeEnum FadeMode
        {
            get { return _FadeMode; }
            set { _FadeMode = value; }
        }

        //TODO: Maybe split fademode into fademodeactive and fademode inactive

        private int _FadeInactiveDurationMs = 500;

        public int FadeInactiveDurationMs
        {
            get { return _FadeInactiveDurationMs; }
            set { _FadeInactiveDurationMs = value; }
        }


        private int _FadeActiveDurationMs = 500;

        public int FadeActiveDurationMs
        {
            get { return _FadeActiveDurationMs; }
            set { _FadeActiveDurationMs = value; }
        }



        float[] Current = new float[4];
        float[] Step = new float[4];
        float[] Target = new float[4];
        bool IsFading = false;

        private void StartFading(bool Active)
        {
            Table.Pinball.Alarms.UnregisterAlarm(FadingStep);

            RGBAColor TargetColor = (Active ? ActiveColor : InactiveColor);

            int Duration = (Active ? FadeActiveDurationMs : FadeInactiveDurationMs);
            int Steps = Duration / FadingRefreshIntervalMs;

            if (Steps > 0)
            {
                IsFading = true;

                RGBAColor CurrentColor;
                switch (FadeMode)
                {
                    case FadeModeEnum.CurrentToDefined:
                        CurrentColor = RGBAToy.Layers[Layer].GetRGBAColor();
                        break;
                    case FadeModeEnum.DefinedToDefined:
                    default:
                        CurrentColor = (!Active ? ActiveColor.GetRGBAColor() : InactiveColor.GetRGBAColor());
                        break;
                }

                Current[0] = CurrentColor.Red;
                Current[1] = CurrentColor.Green;
                Current[2] = CurrentColor.Blue;
                Current[3] = CurrentColor.Alpha;

                Target[0] = TargetColor.Red;
                Target[1] = TargetColor.Green;
                Target[2] = TargetColor.Blue;
                Target[3] = TargetColor.Alpha;

                for (int i = 0; i < 4; i++)
                {
                    Step[i] = (Target[i] - Current[i]) / Steps;
                }

                FadingStep();
            }
            else
            {
                RGBAToy.Layers[Layer].Set(TargetColor);
            }
        }

        private void FadingStep()
        {
            bool ContinueFading = false;
            for (int i = 0; i < 4; i++)
            {
                if (Step[i] > 0)
                {
                    Current[i] += Step[i];
                    if (Current[i] < Target[i] && Current[i] < 255)
                    {
                        ContinueFading = true;
                    }
                    else
                    {
                        Current[i] = Target[i];
                        Step[i] = 0;
                    }
                }
                else if (Step[i] < 0)
                {
                    Current[i] += Step[i];
                    if (Current[i] > Target[i] && Current[i] > 0)
                    {
                        ContinueFading = true;
                    }
                    else
                    {
                        Current[i] = Target[i];
                        Step[i] = 0;
                    }
                }
            }

            RGBAToy.Layers[Layer].Set((int)Current[0], (int)Current[1], (int)Current[2], (int)Current[3]);

            if (ContinueFading)
            {
                Table.Pinball.Alarms.RegisterAlarm(FadingRefreshIntervalMs, FadingStep);
                IsFading = true;
            }
            else
            {
                IsFading = false;
            }
        }




        private RGBAColor _ActiveColor = new RGBAColor(0, 0, 0, 0);

        public RGBAColor ActiveColor
        {
            get { return _ActiveColor; }
            set { _ActiveColor = value; }
        }


        private RGBAColor _InactiveColor = new RGBAColor(0, 0, 0, 0);

        public RGBAColor InactiveColor
        {
            get { return _InactiveColor; }
            set { _InactiveColor = value; }
        }



        bool LastTriggerState = false;
        public override void Trigger(Table.TableElementData TableElementData)
        {
            if (RGBAToy != null)
            {
                bool TriggerState = (TableElementData == null || TableElementData.Value != 0);

                if (TriggerState != LastTriggerState || IsFading == false || RetriggerBehaviour == RetriggerBehaviourEnum.RestartEffect)
                {
                    StartFading(TriggerState);
                }

                LastTriggerState = TriggerState;
            }
        }

        public override void Finish()
        {
            try
            {
                Table.Pinball.Alarms.UnregisterAlarm(FadingStep);
            }
            catch { } 
            if (RGBAToy != null)
            {
                RGBAToy.Layers.Remove(Layer);
            }
            base.Finish();
        }

    }
}