AnalogToyFadeOnOffEffect.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;

namespace DirectOutput.FX.AnalogToyFX
{
    public class AnalogToyFadeOnOffEffect : AnanlogToyEffectBase
    {
        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; }
        }




        private AnalogAlphaValue _ActiveValue = new AnalogAlphaValue(255, 255);

        public AnalogAlphaValue ActiveValue
        {
            get { return _ActiveValue; }
            set { _ActiveValue = value; }
        }

        private AnalogAlphaValue _InactiveValue = new AnalogAlphaValue(0, 0);

        public AnalogAlphaValue InactiveValue
        {
            get { return _InactiveValue; }
            set { _InactiveValue = value; }
        }




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

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

            AnalogAlphaValue TargetValue = (Active ? ActiveValue : InactiveValue);

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

            if (Steps > 0)
            {

                IsFading = true;

                AnalogAlphaValue CurrentAnalogAlphaValue;
                switch (FadeMode)
                {
                    case FadeModeEnum.CurrentToDefined:
                        CurrentAnalogAlphaValue = Toy.Layers[Layer].GetAnalogAlphaValue();
                        break;
                    case FadeModeEnum.DefinedToDefined:
                    default:
                        CurrentAnalogAlphaValue = (!Active ? ActiveValue : InactiveValue);
                        break;
                }

                Current[0] = CurrentAnalogAlphaValue.Value;
                Current[1] = CurrentAnalogAlphaValue.Alpha;

                Target[0] = TargetValue.Value;
                Target[1] = TargetValue.Alpha;


                for (int i = 0; i < 2; i++)
                {
                    Step[i] = (Target[i] - Current[i]) / Steps;
                }
                FadingStep();
            }
            else
            {
                Toy.Layers[Layer].Set(TargetValue);
            }

        }

        private void FadingStep()
        {
            bool ContinueFading = false;
            for (int i = 0; i < 2; 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;
                    }
                }
            }

            Toy.Layers[Layer].Set((int)Current[0], (int)Current[1]);

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

        bool LastTriggerState = false;
        public override void Trigger(Table.TableElementData TableElementData)
        {
            if (Toy != null)
            {

                bool TriggerState = TableElementData.Value != 0;

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

                LastTriggerState = TriggerState;
            }
        }


        public override void Init(Table.Table Table)
        {
            base.Init(Table);
        }

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