MatrixBitmapAnimationEffectBase.cs

Go to the documentation of this file.

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

namespace DirectOutput.FX.MatrixFX
{
    public abstract class MatrixBitmapAnimationEffectBase<MatrixElementType> : MatrixEffectBase<MatrixElementType>, IMatrixBitmapEffect
    {
        private MatrixAnimationStepDirectionEnum _AnimationStepDirection = MatrixAnimationStepDirectionEnum.Frame;

        public MatrixAnimationStepDirectionEnum AnimationStepDirection
        {
            get { return _AnimationStepDirection; }
            set { _AnimationStepDirection = value; }
        }

        private int _AnimationStepSize = 1;

        public int AnimationStepSize
        {
            get { return _AnimationStepSize; }
            set { _AnimationStepSize = value; }
        }


        private int _AnimationFrameCount = 1;

        public int AnimationFrameCount
        {
            get { return _AnimationFrameCount; }
            set { _AnimationFrameCount = value.Limit(1, int.MaxValue); }
        }

        private AnimationBehaviourEnum _AnimationBehaviour= AnimationBehaviourEnum.Loop;

        public AnimationBehaviourEnum AnimationBehaviour
        {
            get { return _AnimationBehaviour; }
            set { _AnimationBehaviour = value; }
        }
        

        private int _AnimationFrameDurationMs = 30;

        public int AnimationFrameDurationMs
        {
            get { return _AnimationFrameDurationMs; }
            set { _AnimationFrameDurationMs = value.Limit(1,int.MaxValue); }
        }



        private int _BitmapFrameNumber = 0;

        public int BitmapFrameNumber
        {
            get { return _BitmapFrameNumber; }
            set { _BitmapFrameNumber = value; }
        }

        private int _BitmapTop = 0;

        public int BitmapTop
        {
            get { return _BitmapTop; }
            set { _BitmapTop = value.Limit(0,int.MaxValue); }
        }

        private int _BitmapLeft = 0;

        public int BitmapLeft
        {
            get { return _BitmapLeft; }
            set { _BitmapLeft = value.Limit(0, int.MaxValue); }
        }

        private int _BitmapWidth = -1;

        public int BitmapWidth
        {
            get { return _BitmapWidth; }
            set { _BitmapWidth = value.Limit(-1, int.MaxValue); }
        }

        private int _BitmapHeight = -1;

        public int BitmapHeight
        {
            get { return _BitmapHeight; }
            set { _BitmapHeight = value.Limit(-1, int.MaxValue); }
        }


        private FastBitmapDataExtractModeEnum _DataExtractMode = FastBitmapDataExtractModeEnum.BlendPixels;

        public FastBitmapDataExtractModeEnum DataExtractMode
        {
            get { return _DataExtractMode; }
            set { _DataExtractMode = value; }
        }



        private FilePattern _BitmapFilePattern;

        public FilePattern BitmapFilePattern
        {
            get { return _BitmapFilePattern; }
            set { _BitmapFilePattern = value; }
        }

        protected PixelData[][,] Pixels;


        private bool AnimationActive = false;
        private int AnimationStep = 0;
        private int AnimationFadeValue = 0;
        private void Animate()
        {
            

            for (int y = 0; y < AreaHeight; y++)
            {
                int yd = y + AreaTop;
                for (int x = 0; x < AreaWidth; x++)
                {
                    int xd = x + AreaLeft;
                    MatrixLayer[xd, yd] = GetEffectValue(AnimationFadeValue, Pixels[AnimationStep][x, y]);
                }
            }

          

            AnimationStep++;
            if (AnimationStep >= Pixels.GetUpperBound(0))
            {
                AnimationStep = 0;
                if (AnimationBehaviour == AnimationBehaviourEnum.Once)
                {
                    StopAnimation();
                }
            }

        }

        private void Clear()
        {
            MatrixElementType Off = GetEffectValue(0, new PixelData());

            for (int y = AreaTop; y <= AreaBottom; y++)
            {
               
                for (int x = AreaLeft; x <= AreaRight; x++)
                {
                    MatrixLayer[x, y] = Off;
                }
            }

        }

        protected abstract MatrixElementType GetEffectValue(int TriggerValue, PixelData Pixel);


        private void ControlAnimation(int FadeValue)
        {
            if (FadeValue > 0)
            {
                //Start animation
                this.AnimationFadeValue = FadeValue;

                if (!AnimationActive)
                {
                    AnimationActive = true;

                    if (AnimationBehaviour != AnimationBehaviourEnum.Continue)
                    {
                        AnimationStep = 0;
                    }
                    Table.Pinball.Alarms.RegisterIntervalAlarm(AnimationFrameDurationMs, Animate);

                    Animate();
                }
            }
            else
            {
                //Stop animation
                StopAnimation();
            }



        }

        private void StopAnimation()
        {
            if (AnimationActive)
            {
 
                try
                {
                    Table.Pinball.Alarms.UnregisterIntervalAlarm(Animate);
                }
                catch { };

                AnimationActive = false;
                
                Clear();
            }
        }




        public override void Trigger(Table.TableElementData TableElementData)
        {
            if (InitOK)
            {
                int FadeValue = TableElementData.Value;
                if (FadeMode == FadeModeEnum.OnOff) FadeValue = (FadeValue < 1 ? 0 : 255);
                ControlAnimation(FadeValue);

                
            }

        }

        private bool InitOK = false;


        public override void Init(Table.Table Table)
        {
            InitOK = false;
            Pixels = null;
            base.Init(Table);

            //TODO: Insert replace values for file pattern
            if (BitmapFilePattern.IsValid)
            {

                string Filename = BitmapFilePattern.GetFirstMatchingFile(Table.Pinball.GlobalConfig.GetReplaceValuesDictionary()).FullName;
                if (!Filename.IsNullOrWhiteSpace())
                {
                    FastImage BM;
                    try
                    {
                        BM = Table.Bitmaps[Filename];
                    }
                    catch (Exception E)
                    {
                        Log.Exception("MatrixBitmapAnimationEffectBase {0} cant initialize.  Could not load file {1}.".Build(Name, Filename), E);
                        return;
                    }

                    if (BM.Frames.ContainsKey(BitmapFrameNumber))
                    {
                        int StepCount = AnimationFrameCount;
                        switch (AnimationStepDirection)
                        {
                            case MatrixAnimationStepDirectionEnum.Frame:
                                if ((BitmapFrameNumber + (StepCount * AnimationStepSize)) > BM.Frames.Count)
                                {
                                    StepCount = (BM.Frames.Count - BitmapFrameNumber) / AnimationStepSize;
                                }

                                Pixels = new PixelData[StepCount][,];


                                for (int s = 0; s < StepCount; s++)
                                {
                                    
                                    Pixels[s] = BM.Frames[BitmapFrameNumber + s].GetClip(AreaWidth, AreaHeight, BitmapLeft, BitmapTop, BitmapWidth, BitmapHeight, DataExtractMode).Pixels;
                                }



                                break;
                            case MatrixAnimationStepDirectionEnum.Right:
                                //TODO: Check if there should be a restriction of steps for this direction


                                Pixels = new PixelData[StepCount][,];

                                for (int s = 0; s < StepCount; s++)
                                {
                                    Pixels[s] = BM.Frames[BitmapFrameNumber].GetClip(AreaWidth, AreaHeight, BitmapLeft+s*AnimationStepSize, BitmapTop, BitmapWidth, BitmapHeight, DataExtractMode).Pixels;
                                }

                                break;
                            case MatrixAnimationStepDirectionEnum.Down:
                                //TODO: Check if there should be a restriction of steps for this direction
                                 Pixels = new PixelData[StepCount][,];

                                for (int s = 0; s < StepCount; s++)
                                {
                                    Pixels[s] = BM.Frames[BitmapFrameNumber].GetClip(AreaWidth, AreaHeight, BitmapLeft, BitmapTop + s * AnimationStepSize, BitmapWidth, BitmapHeight, DataExtractMode).Pixels;
                                }

                                break;
                            default:
                                StepCount = 1;
                                Pixels = new PixelData[StepCount][,];
                                for (int s = 0; s < StepCount; s++)
                                {
                                    Pixels[s] = BM.Frames[BitmapFrameNumber].GetClip(AreaWidth, AreaHeight, BitmapLeft, BitmapTop, BitmapWidth, BitmapHeight, DataExtractMode).Pixels;
                                }
                                break;
                        }

                        Log.Debug("BitmapAnimationEffectBase. Grabbed image clips: W: {0}, H:{1}, BML: {2}, BMT: {3}, BMW: {4}, BMH: {5}, Steps: {6}".Build(new object[] { AreaWidth, AreaHeight, BitmapLeft, BitmapTop, BitmapWidth, BitmapHeight, StepCount }));


                    }
                    else
                    {
                        Log.Warning("MatrixBitmapAnimationEffectBase {0} cant initialize. Frame {1} does not exist in source image {2}.".Build(Name, BitmapFrameNumber, Filename));

                    }
                }
                else
                {
                    Log.Warning("MatrixBitmapAnimationEffectBase {0} cant initialize. No file matches the BitmapFilePattern {1} is invalid".Build(Name, BitmapFilePattern.ToString()));
                }
            }
            else
            {
                Log.Warning("MatrixBitmapAnimationEffectBase {0} cant initialize. The BitmapFilePattern {1} is invalid".Build(Name, BitmapFilePattern.ToString()));
            }


            InitOK = (Pixels != null && MatrixLayer != null);

        }

        public override void Finish()
        {
            StopAnimation();
            Pixels = null;
            base.Finish();
        }


    }
}