SpriteBase.cs

//-----------------------------------------------------------------
//  Copyright 2010 Brady Wright and Above and Beyond Software
//      All rights reserved
//-----------------------------------------------------------------


using UnityEngine;
using System.Collections;


[System.Serializable]
public class UVAnimation
{
        public enum ANIM_END_ACTION
        {
                Do_Nothing,

                Revert_To_Static,

                Play_Default_Anim,

                Hide,

                Deactivate,

                Destroy
        };


        protected SPRITE_FRAME[] frames;                                        // Array of values defining the frames of an animation

        // Animation state vars:
        protected int curFrame = -1;                                    // The current frame
        protected int stepDir = 1;                                              // The direction we're currently playing the animation (1=forwards (default), -1=backwards)
        protected int numLoops = 0;                                             // Number of times we've looped since last animation
        protected bool playInReverse = false;                   // Indicates that we've been instructed to play in reverse, as opposed to reversing merely as a result of loopReverse.

        protected float length;                                                 // Length of the clip, in seconds (not taking into account looping, loop reversing, etc)

        public string name;                                                             // The name of the 

        public int loopCycles = 0;                                              // How many times to loop the animation (-1 loop infinitely)
        
        public bool loopReverse = false;                                // Reverse the play direction when the end of the animation is reached? (if true, a loop iteration isn't counted until we return to the beginning)

        [HideInInspector]
        public float framerate = 15f;                                   // The rate in frames per second at which to play the animation

        [HideInInspector]
        public int index = -1;

        [HideInInspector]
        public ANIM_END_ACTION onAnimEnd = ANIM_END_ACTION.Do_Nothing;

        public int StepDirection
        {
                get     {       return stepDir; }
                set { SetStepDir(value); }
        }

        // Copy constructor:
        public UVAnimation(UVAnimation anim)
        {
                frames = new SPRITE_FRAME[anim.frames.Length];
                anim.frames.CopyTo(frames, 0);

                name = anim.name;

                loopCycles = anim.loopCycles;
                loopReverse = anim.loopReverse;
                framerate = anim.framerate;
                onAnimEnd = anim.onAnimEnd;

                curFrame = anim.curFrame;
                stepDir = anim.stepDir;
                numLoops = anim.numLoops;
                playInReverse = anim.playInReverse;
                length = anim.length;

                CalcLength();
        }

        public UVAnimation Clone()
        {
                return new UVAnimation(this);
        }
        
        public UVAnimation()
        {
                frames = new SPRITE_FRAME[0];
        }

        public void Reset()
        {
                curFrame = -1;
                stepDir = 1;
                numLoops = 0;
                playInReverse = false;
        }

        // Sets the stepDir to -1 and sets the current frame to the end
        // so that the animation plays in reverse
        public void PlayInReverse()
        {
                stepDir = -1;
                curFrame = frames.Length;
                numLoops = 0;
                playInReverse = true;
        }

        public void SetStepDir(int dir)
        {
                if (dir < 0)
                {
                        stepDir = -1;
                        playInReverse = true;
                }
                else
                        stepDir = 1;
        }

        // Stores the UV and other info of the next frame in 'nextFrame', 
        // returns false if we've reached the end of the animation (this 
        // will never happen if it is set to loop infinitely)
        public bool GetNextFrame(ref SPRITE_FRAME nextFrame)
        {
                if (frames.Length < 1)
                        return false;

                // See if we can advance to the next frame:
                if ((curFrame + stepDir) >= frames.Length || (curFrame + stepDir) < 0)
                {
                        // See if we need to loop (if we're reversing, we don't loop until we get back to the beginning):
                        if (stepDir > 0 && loopReverse)
                        {
                                stepDir = -1;   // Reverse playback direction
                                curFrame += stepDir;

                                curFrame = Mathf.Clamp(curFrame, 0, frames.Length - 1);

                                nextFrame = frames[curFrame];
                        }
                        else
                        {
                                // See if we can loop:
                                if (numLoops + 1 > loopCycles && loopCycles != -1)
                                        return false;
                                else
                                {       // Loop the animation:
                                        ++numLoops;

                                        if (loopReverse)
                                        {
                                                stepDir *= -1;
                                                curFrame += stepDir;
                                                curFrame = Mathf.Clamp(curFrame, 0, frames.Length - 1);
                                        }
                                        else
                                        {
                                                if (playInReverse)
                                                        curFrame = frames.Length - 1;
                                                else
                                                        curFrame = 0;
                                        }

                                        nextFrame = frames[curFrame];
                                }
                        }
                }
                else
                {
                        curFrame += stepDir;
                        nextFrame = frames[curFrame];
                }

                return true;
        }


        public SPRITE_FRAME GetCurrentFrame()
        {
                return frames[Mathf.Clamp(curFrame, 0, curFrame)];
        }


        public SPRITE_FRAME GetFrame(int frame)
        {
                return frames[frame];
        }


        public SPRITE_FRAME[] BuildUVAnim(Vector2 start, Vector2 cellSize, int cols, int rows, int totalCells)
        {
                int cellCount = 0;

                frames = new SPRITE_FRAME[totalCells];

                frames[0] = new SPRITE_FRAME(0);
                frames[0].uvs.x = start.x;
                frames[0].uvs.y = start.y;
                frames[0].uvs.xMax = start.x + cellSize.x;
                frames[0].uvs.yMax = start.y + cellSize.y;

                for (int row = 0; row < rows; ++row)
                {
                        for (int col = 0; col < cols && cellCount < totalCells; ++col)
                        {
                                frames[cellCount] = new SPRITE_FRAME(0);
                                frames[cellCount].uvs.x = start.x + cellSize.x * ((float)col);
                                frames[cellCount].uvs.y = start.y - cellSize.y * ((float)row);
                                frames[cellCount].uvs.xMax = frames[cellCount].uvs.x + cellSize.x;
                                frames[cellCount].uvs.yMax = frames[cellCount].uvs.y + cellSize.y;

                                ++cellCount;
                        }
                }

                CalcLength();
                
                return frames;
        }


        public SPRITE_FRAME[] BuildWrappedUVAnim(Vector2 start, Vector2 cellSize, int cols, int rows, int totalCells)
        {
                return BuildWrappedUVAnim(start, cellSize, totalCells);
        }


        public SPRITE_FRAME[] BuildWrappedUVAnim(Vector2 start, Vector2 cellSize, int totalCells)
        {
                int cellCount = 0;
                Vector2 curPos;

                frames = new SPRITE_FRAME[totalCells];

                frames[0] = new SPRITE_FRAME(0);
                frames[0].uvs.x = start.x;
                frames[0].uvs.y = start.y;
                frames[0].uvs.xMax = start.x + cellSize.x;
                frames[0].uvs.yMax = start.y + cellSize.y;

                curPos = start;

                for (cellCount = 1; cellCount < totalCells; ++cellCount)
                {
                        curPos.x += cellSize.x;
                        if (curPos.x + cellSize.x > 1.01f)
                        {
                                curPos.x = 0;
                                curPos.y -= cellSize.y;
                        }

                        frames[cellCount] = new SPRITE_FRAME(0);
                        frames[cellCount].uvs.x = curPos.x;
                        frames[cellCount].uvs.y = curPos.y;
                        frames[cellCount].uvs.xMax = curPos.x + cellSize.x;
                        frames[cellCount].uvs.yMax = curPos.y + cellSize.y;
                }

                return frames;
        }


        public void SetAnim(SPRITE_FRAME[] anim)
        {
                frames = anim;
                CalcLength();
        }

        public void SetAnim(TextureAnim anim, int idx)
        {
                if (anim == null)
                        return;
                if (anim.spriteFrames == null)
                        return;

                frames = new SPRITE_FRAME[anim.spriteFrames.Length];

                index = idx;
                name = anim.name;
                loopCycles = anim.loopCycles;
                loopReverse = anim.loopReverse;
                framerate = anim.framerate;
                onAnimEnd = anim.onAnimEnd;

                try
                {
                        for (int i = 0; i < frames.Length; ++i)
                        {
                frames[i] = anim.spriteFrames[i].ToStruct();
                        }
                }
                catch (System.Exception err)
                {
                        Debug.LogError("Exception caught in UVAnimation.SetAnim(). Make sure you have re-built your atlases!\nException: " + err.Message);
                }

                CalcLength();
        }

        public void AppendAnim(SPRITE_FRAME[] anim)
        {
                SPRITE_FRAME[] tempFrames = frames;

                frames = new SPRITE_FRAME[frames.Length + anim.Length];
                tempFrames.CopyTo(frames, 0);
                anim.CopyTo(frames, tempFrames.Length);

                CalcLength();
        }

        public void SetCurrentFrame(int f)
        {
                // Allow to go 1 out of bounds since this is
                // how we prepare to "advance" to the first or
                // last frame:
                f = Mathf.Clamp(f, -1, frames.Length + 1);

                curFrame = f;
        }

        public void SetPosition(float pos)
        {
                pos = Mathf.Clamp01(pos);

                // If this is an infinitely looping animation,
                // or a single-play animation, just set the
                // position within the clip:
                if (loopCycles < 1)
                {
                        SetClipPosition(pos);
                        return;
                }

                // The percentage of total animation that is
                // accounted for by a single loop iteration:
                float iterationPct = 1f / (loopCycles + 1f);

                // The loop iteration containing the desired
                // frame:
                numLoops = Mathf.FloorToInt(pos / iterationPct);

                // Portion of our "pos" that is unaccounted for
                // merely by counting loop iterations:
                float remainder = pos - (((float)numLoops) * iterationPct);

                // Position within the "clip" (the "clip" being 
                // the series of frames between the first frame 
                // and last frame, without regard to the loop cycles)
                float clipPos = remainder / iterationPct;

                if(loopReverse)
                {
                        if (clipPos < 0.5f)
                        {
                                curFrame = (int) ( ((float)frames.Length-1) * (clipPos/0.5f) );
                                // We're stepping forward from here:
                                stepDir = 1;
                        }
                        else
                        {
                                curFrame = (frames.Length-1) - (int)(((float)frames.Length-1) * ((clipPos-0.5f) / 0.5f));
                                // We're stepping backwards from here:
                                stepDir = -1;
                        }
                }
                else
                {
                        curFrame = (int) ( ((float)frames.Length-1) * clipPos );
                }
        }

        public void SetClipPosition(float pos)
        {
                curFrame = (int)(((float)frames.Length - 1) * pos);
        }

        // Calculates the length of the animation clip (not accounting for looping, loop reversing, etc)
        protected void CalcLength()
        {
                length = (1f / framerate) * frames.Length;
        }

        public float GetLength()
        {
                return length;
        }

        public float GetDuration()
        {
                // If this loops infinitely, return -1:
                if(loopCycles < 0)
                        return -1f;

                float length = GetLength();

                if (loopReverse)
                        length *= 2f;

                return length + (loopCycles * length);
        }

        public int GetFrameCount()
        {
                return frames.Length;
        }

        public int GetFramesDisplayed()
        {
                if (loopCycles == -1)
                        return -1;

                int count = frames.Length + (frames.Length * loopCycles);
                
                if (loopReverse)
                        count *= 2;

                return count;
        }

        public int GetCurPosition()
        {
                return curFrame;
        }
}


[System.Serializable]
public class UVAnimation_Auto : UVAnimation
{
        public Vector2 start;

        public Vector2 pixelsToNextColumnAndRow;

        public int cols;
        
        public int rows;

        public int totalCells;

        // No-arg constructor:
        public UVAnimation_Auto() {}

        // Copy constructor:
        public UVAnimation_Auto(UVAnimation_Auto anim) : base(anim)
        {
                start = anim.start;
                pixelsToNextColumnAndRow = anim.pixelsToNextColumnAndRow;
                cols = anim.cols;
                rows = anim.rows;
                totalCells = anim.totalCells;
        }

        public new UVAnimation_Auto Clone()
        {
                return new UVAnimation_Auto(this);
        }
        
        public SPRITE_FRAME[] BuildUVAnim(SpriteRoot s)
        {
                if (totalCells < 1)
                        return null;

                return this.BuildUVAnim(s.PixelCoordToUVCoord(start), s.PixelSpaceToUVSpace(pixelsToNextColumnAndRow), cols, rows, totalCells);
        }
}


[System.Serializable]
public class UVAnimation_Multi
{
        public string name;                                     // The name of the animation sequence

        public int loopCycles = 0;                      // How many times to loop the animation (-1 loop infinitely)

        public bool loopReverse = false;        // Reverse the play direction when the end of the animation is reached? (if true, a loop iteration isn't counted until we return to the beginning)

        public float framerate = 15f;           // The rate in frames per second at which to play the animation

        public UVAnimation.ANIM_END_ACTION onAnimEnd = UVAnimation.ANIM_END_ACTION.Do_Nothing;

        public UVAnimation_Auto[] clips;        // The actual sprite animation clips that make up this animation sequence

        [HideInInspector]
        public int index;

        protected int curClip;                          // Index of the currently-playing clip
        protected int stepDir = 1;                      // The direction to step through our clips (1 == forwards, -1 == backwards)
        protected int numLoops = 0;                     // Number of times we've looped since last animation

        protected float duration;                       // The duration of the animation, accounting for looping and loop reversing.


        // Working vars:
        protected bool ret;
        protected int i;
        protected int framePos = -1;            // Keeps track of which frame (over all) we are on in the animation multi.
                                                                                // In other words, if the multi contains a total of 100 frames across all 
                                                                                // sub-animations, then this value will count from 0-99 (and back again if
                                                                                // if we're reversing).


        public UVAnimation_Multi()
        {
                if (clips == null)
                        clips = new UVAnimation_Auto[0];
        }

        // Copy constructor:
        public UVAnimation_Multi(UVAnimation_Multi anim)
        {
                name = anim.name;
                loopCycles = anim.loopCycles;
                loopReverse = anim.loopReverse;
                framerate = anim.framerate;
                onAnimEnd = anim.onAnimEnd;
                curClip = anim.curClip;
                stepDir = anim.stepDir;
                numLoops = anim.numLoops;
                duration = anim.duration;

                clips = new UVAnimation_Auto[anim.clips.Length];
                for (int i = 0; i < clips.Length; ++i)
                        clips[i] = anim.clips[i].Clone();

                CalcDuration();
        }

        public UVAnimation_Multi Clone()
        {
                return new UVAnimation_Multi(this);
        }

        public UVAnimation_Auto GetCurrentClip()
        {
                return clips[curClip];
        }

        public int StepDirection
        {
                get { return stepDir; }
                set { stepDir = value; }
        }

        public UVAnimation_Auto[] BuildUVAnim(SpriteRoot s)
        {
                for (i = 0; i < clips.Length; ++i)
                {
                        clips[i].BuildUVAnim(s);
                }

                CalcDuration();

                return clips;
        }

        public bool GetNextFrame(ref SPRITE_FRAME nextFrame)
        {
                if (clips.Length < 1)
                        return false;

                ret = clips[curClip].GetNextFrame(ref nextFrame);

                if (!ret)
                {
                        // See if we have another clip in the queue:
                        if ((curClip + stepDir) >= clips.Length || (curClip + stepDir) < 0)
                        {
                                // See if we need to loop (if we're reversing, we don't loop until we get back to the beginning):
                                if (stepDir > 0 && loopReverse)
                                {
                                        stepDir = -1;   // Reverse playback direction
                                        curClip += stepDir;

                                        curClip = Mathf.Clamp(curClip, 0, clips.Length - 1);

                                        // Make the newly selected clip ready for playing:
                                        clips[curClip].Reset();
                                        clips[curClip].PlayInReverse();
                                        // Go ahead and step one since it will start
                                        // at the end, and that's where we are already:
                                        clips[curClip].GetNextFrame(ref nextFrame);
                                }
                                else
                                {
                                        // See if we can loop:
                                        if (numLoops + 1 > loopCycles && loopCycles != -1)
                                                return false;   // We've reached the end of the last clip
                                        else
                                        {       // Loop the animation:
                                                ++numLoops;

                                                if (loopReverse)
                                                {
                                                        stepDir *= -1;
                                                        curClip += stepDir;

                                                        curClip = Mathf.Clamp(curClip, 0, clips.Length - 1);

                                                        // Make the newly selected clip ready for playing:
                                                        clips[curClip].Reset();

                                                        if (stepDir < 0)
                                                                clips[curClip].PlayInReverse();

                                                        // Go ahead and step one since it will start
                                                        // where we are already:
                                                        clips[curClip].GetNextFrame(ref nextFrame);
                                                }
                                                else
                                                {
                                                        curClip = 0;
                                                        framePos = -1;

                                                        // Make the newly selected clip ready for playing:
                                                        clips[curClip].Reset();
                                                }
                                        }
                                }
                        }
                        else
                        {
                                curClip += stepDir;

                                // Make the newly selected clip ready for playing:
                                clips[curClip].Reset();

                                if (stepDir < 0)
                                {
                                        clips[curClip].PlayInReverse();
                                        // Go ahead and step one since it will start
                                        // at the end, and that's where we are already:
                                        clips[curClip].GetNextFrame(ref nextFrame);
                                }
                        }

                        framePos += stepDir;

                        // Get the next frame since our previous
                        // attempt failed, and all that we just
                        // did was to be able to get the next one:
                        clips[curClip].GetNextFrame(ref nextFrame);

                        return true;    // Keep playing
                }

                framePos += stepDir;

                /*
                                // Simpler, non-looping logic:
                                if (curClip < clips.Length - 1)
                                {
                                        // Go to the next clip:
                                        ++curClip;
                                        return true;    // Keep playing
                                }
                                else
                                        return false;   // We've reached the end of the last clip
                */

                return true;
        }


        public SPRITE_FRAME GetCurrentFrame()
        {
                return clips[Mathf.Clamp(curClip, 0, curClip)].GetCurrentFrame();
        }


        public void AppendAnim(int index, SPRITE_FRAME[] anim)
        {
                if (index >= clips.Length)
                        return;

                clips[index].AppendAnim(anim);

                CalcDuration();
        }

        public void AppendClip(UVAnimation clip)
        {
                UVAnimation[] temp;
                temp = clips;

                clips = new UVAnimation_Auto[clips.Length + 1];
                temp.CopyTo(clips, 0);

                clips[clips.Length - 1] = (UVAnimation_Auto)clip;

                CalcDuration();
        }

        public void PlayInReverse()
        {
                for (i = 0; i < clips.Length; ++i)
                {
                        clips[i].PlayInReverse();
                }

                stepDir = -1;
                framePos = GetFrameCount()-1;
                curClip = clips.Length - 1;
        }

        public void SetAnim(int index, SPRITE_FRAME[] frames)
        {
                if (index >= clips.Length)
                        return;

                clips[index].SetAnim(frames);

                CalcDuration();
        }

        public void Reset()
        {
                curClip = 0;
                stepDir = 1;
                numLoops = 0;
                framePos = -1;

                for (i = 0; i < clips.Length; ++i)
                {
                        clips[i].Reset();
                }
        }

        public void SetPosition(float pos)
        {
                pos = Mathf.Clamp01(pos);

                // If this is an infinitely looping animation,
                // or if it is a single-play animation, just
                // set the position:
                if(loopCycles < 1)
                {
                        SetAnimPosition(pos);
                        return;
                }

                // The percentage of total animation that is
                // accounted for by a single loop iteration:
                float iterationPct = 1f / (loopCycles + 1f);

                // Find the loop iteration of the desired position:
                numLoops = Mathf.FloorToInt(pos / iterationPct);

                // Portion of our "pos" that is unaccounted for
                // merely by counting loop iterations:
                float remainder = pos - (((float)numLoops) * iterationPct);

                SetAnimPosition(remainder / iterationPct);
        }

        public void SetAnimPosition(float pos)
        {
                int totalFrames = 0;
                float pct;
                float remaining = pos;

                // Get the total number of frames:
                for (int n = 0; n < clips.Length; ++n)
                {
                        totalFrames += clips[n].GetFramesDisplayed();
                }

                // Find which clip our desired position is in:
                if(loopReverse)
                {
                        if(pos < 0.5f)
                        {
                                // We will step forward from here:
                                stepDir = 1;

                                // Adjust to account for the fact that a value
                                // of .5 in this context means 100% of the way
                                // from the first frame to the last frame:
                                remaining *= 2f;

                                for (int n = 0; n < clips.Length; ++n)
                                {
                                        // Get the percentage of our animation
                                        // that is accounted for by this clip:
                                        pct = clips[n].GetFramesDisplayed() / totalFrames;

                                        // If the distance we have left to go into
                                        // our animation is less than the distance
                                        // accounted for by this clip, this is the
                                        // clip we're looking for!:
                                        if (remaining <= pct)
                                        {
                                                curClip = n;
                                                clips[curClip].SetPosition(remaining / pct);

                                                framePos = ((int)pct * (totalFrames-1));

                                                return;
                                        }
                                        else
                                                remaining -= pct;
                                }
                        }
                        else
                        {
                                // We will step backward from here:
                                stepDir = -1;

                                // Adjust for the fact that in this context, 
                                // a value of .5 means 0% of the way from the
                                // last frame to the first frame:
                                remaining = (remaining-0.5f) / 0.5f;

                                for (int n = clips.Length-1; n >= 0; --n)
                                {
                                        // Get the percentage of our animation
                                        // that is accounted for by this clip:
                                        pct = clips[n].GetFramesDisplayed() / totalFrames;

                                        // If the distance we have left to go into
                                        // our animation is less than the distance
                                        // accounted for by this clip, this is the
                                        // clip we're looking for!:
                                        if (remaining <= pct)
                                        {
                                                curClip = n;
                                                clips[curClip].SetPosition(1f - (remaining / pct));
                                                clips[curClip].SetStepDir(-1);

                                                framePos = ((int)pct * (totalFrames - 1));
                                                
                                                return;
                                        }
                                        else
                                                remaining -= pct;
                                }
                        }
                }
                else
                {
                        for (int n = 0; n < clips.Length; ++n)
                        {
                                // Get the percentage of our animation
                                // that is accounted for by this clip:
                                pct = clips[n].GetFramesDisplayed() / totalFrames;

                                // If the distance we have left to go into
                                // our animation is less than the distance
                                // accounted for by this clip, this is the
                                // clip we're looking for!:
                                if (remaining <= pct)
                                {
                                        curClip = n;
                                        clips[curClip].SetPosition(remaining / pct);

                                        framePos = ((int)pct * (totalFrames - 1));
                                        
                                        return;
                                }
                                else
                                        remaining -= pct;
                        }
                }
        }

        // Calculates the duration of the animation:
        protected void CalcDuration()
        {
                // If this loops infinitely, set duration to -1:
                if (loopCycles < 0)
                {
                        duration = -1f;
                        return;
                }

                duration = 0;

                for (int n = 0; n < clips.Length; ++n)
                {
                        duration += clips[n].GetDuration();
                }

                if (loopReverse)
                        duration *= 2f;

                duration += (loopCycles * duration);
        }

        public float GetDuration()
        {
                return duration;
        }

        public int GetFrameCount()
        {
                int totalFrames = 0;

                // Get the total number of frames:
                for (int n = 0; n < clips.Length; ++n)
                {
                        totalFrames += clips[n].GetFramesDisplayed();
                }

                return totalFrames;
        }

        public int GetCurPosition()
        {
                return framePos;
        }

        public int GetCurClipNum()
        {
                return curClip;
        }

        public void SetCurClipNum(int index)
        {
                curClip = index;
        }
}



[ExecuteInEditMode]
public abstract class SpriteBase : SpriteRoot, ISpriteAnimatable
{
        // Animation-related vars and types:

        public delegate void AnimCompleteDelegate(SpriteBase sprite);           // Definition of delegate to be called upon animation completion

        public delegate void AnimFrameDelegate(SpriteBase sprite, int frame);

        public bool playAnimOnStart = false;                            // When set to true, will start playing the default animation on start

        // <summary>
        // When set to true, the sprite will crossfade between the current frame
        // and the next frame in the sprite animation.  NOTE: requires the use of the
        // "Crossfade Sprite" shader, which replaces sprite coloring functionality.
        // </summary>
        [HideInInspector]
        public bool crossfadeFrames = false;

        public int defaultAnim = 0;                                                     // Index of the default animation


        protected int curAnimIndex = 0;                                         // Index of the "current" animation, if any

        protected AnimCompleteDelegate animCompleteDelegate = null;     // Delegate to be called upon animation completion
        protected AnimFrameDelegate animFrameDelegate = null; // Delegate to be called each frame
        protected float timeSinceLastFrame = 0;                         // The total time since our last animation frame change
        protected float timeBetweenAnimFrames;                          // The amount of time we want to pass before moving to the next frame of animation
        protected float framesToAdvance;                                        // (working) The number of animation frames to advance given the time elapsed
        protected bool animating = false;                                       // True when an animation is intended to be playing (remains true when object is deactivated while playing an animation)
        protected bool currentlyAnimating = false;                      // True when an animation is actually playing (is false when the object is inactive)

        protected SPRITE_FRAME nextFrameInfo = new SPRITE_FRAME(0);


        protected override void Awake()
        {
                base.Awake();

                // Start the shared animation coroutine if it is not running already:
//              if (!SpriteAnimationPump.pumpIsRunning && Application.isPlaying)
//                      SpriteAnimationPump.Instance.StartAnimationPump();
        }

        public override void Start()
        {
                base.Start();

                if(m_spriteMesh != null)
                        m_spriteMesh.UseUV2 = crossfadeFrames;
        }


        public override void Clear()
        {
                base.Clear();

                //animations.Clear();
                animCompleteDelegate = null;
        }

        public override void Delete()
        {
                if (currentlyAnimating)
                {
                        // Remove ourselves from the animating list.
                        RemoveFromAnimatedList();
                }

                base.Delete();
        }

        // Called when the GO is disabled or destroyed
        protected override void OnDisable()
        {
                base.OnDisable();

                if(animating)
                {
                        // Remove ourselves from the animating list.
                        RemoveFromAnimatedList();

                        // Leave "animating" set to true so that when
                        // we re-enable, we can pick up animating again:
                        animating = true;
                }
        }

        // Called when the GO is enabled or created:
        protected override void OnEnable()
        {
                base.OnEnable();

                // If this is being called in edit mode,
                // disregard:
                if (!Application.isPlaying)
                        return;

                // If we were previously animating,
                // resume animation:
                if (animating)
                {
                        // Set to false so AddToAnimatingList()
                        // won't bail out:
                        animating = false;
                        AddToAnimatedList();
                }
        }

        public override void Copy(SpriteRoot s)
        {
                base.Copy(s);

                if (!(s is SpriteBase))
                        return;

                SpriteBase sb = (SpriteBase)s;

                defaultAnim = sb.defaultAnim;
                playAnimOnStart = sb.playAnimOnStart;
        }

        public override void Hide(bool tf)
        {
                base.Hide(tf);

                // If we're hideAtStart, pause animation:
                if (tf)
                        PauseAnim();
        }


/*
        public virtual void Setup(float width, float height, Vector2 lowerleftPixel, Vector2 pixeldimensions)
        {
                SetSize(width, height);
                lowerLeftPixel = lowerleftPixel;
                pixelDimensions = pixeldimensions;

                tempUV = PixelCoordToUVCoord(lowerLeftPixel);
                uvRect.x = tempUV.x;
                uvRect.y = tempUV.y;

                tempUV = PixelSpaceToUVSpace(pixelDimensions);
                uvRect.xMax = uvRect.x + tempUV.x;
                uvRect.yMax = uvRect.y + tempUV.y;

                SetBleedCompensation(bleedCompensation);
        }
*/


        //-----------------------------------------------------------------
        // Animation-related routines:
        //-----------------------------------------------------------------

        public void SetAnimCompleteDelegate(AnimCompleteDelegate del)
        {
                animCompleteDelegate = del;
        }

        public void SetAnimFrameDelegate(AnimFrameDelegate del)
        {
                animFrameDelegate = del;
        }

        public void SetSpriteResizedDelegate(SpriteResizedDelegate del)
        {
                resizedDelegate = del;
        }

        public void AddSpriteResizedDelegate(SpriteResizedDelegate del)
        {
                resizedDelegate += del;
        }

        public void RemoveSpriteresizedDelegate(SpriteResizedDelegate del)
        {
                resizedDelegate -= del;
        }

        public virtual bool StepAnim(float time) { return false; }

        public virtual void PlayAnim(int index) { }
        public virtual void PlayAnim(string name) { }
        public virtual void PlayAnimInReverse(int index) { }
        public virtual void PlayAnimInReverse(string name) { }
/*      public virtual void PlayAnim(int index, int frame) {}
        public virtual void PlayAnim(string name, int frame) {}
*/

        public void SetFramerate(float fps)
        {
                timeBetweenAnimFrames = 1f / fps;
        }


        public void PauseAnim()
        {
                if(animating)
                        RemoveFromAnimatedList();
                // Stop coroutine
                //animating = false;
                //StopCoroutine("AnimationPump");
                //StopAllCoroutines();
        }


        public virtual void StopAnim(){}


        public void RevertToStatic()
        {
                if (animating)
                        StopAnim();

                InitUVs();
                SetBleedCompensation();

                if (autoResize || pixelPerfect)
                        CalcSize();
        }

        // Adds the sprite to the list of currently
        // animating sprites:
        protected abstract void AddToAnimatedList();

        // Removes the sprite from the list of currently
        // animating sprites:
        protected abstract void RemoveFromAnimatedList();


        //--------------------------------------------------------------
        // Accessors:
        //--------------------------------------------------------------
        public bool IsAnimating() { return animating; }

        public bool Animating
        {
                get { return animating; }

                set
                {
                        if(value)
                                PlayAnim(curAnimIndex);
                }
        }

        public int CurAnimIndex
        {
                get { return curAnimIndex; }            
                set     { curAnimIndex = value; }
        }
}