BrawlLib.Wii.Animations.KeyframeArray Class Reference

Public Member Functions
	KeyframeArray (int limit, float defaultValue=0)
int	Clean ()
KeyframeEntry	GetKeyframe (int index)
float	GetFrameValue (float index, bool returnOutValue=false)
KeyframeEntry	SetFrameValue (int index, float value, bool parsing=false)
KeyframeEntry	Remove (int index)
void	Insert (int index)
void	Delete (int index)
bool	Equals (KeyframeArray obj)

Properties
bool	Loop [get, set]
int	FrameLimit [get, set]
float	this[int index] [get, set]

Constructor & Destructor Documentation

KeyframeArray()

BrawlLib.Wii.Animations.KeyframeArray.KeyframeArray ( int  limit, float  defaultValue = 0  )

inline

        {
            _frameLimit = limit;
            _keyRoot = new KeyframeEntry(-1, defaultValue);
        }

Member Function Documentation

Clean()

int BrawlLib.Wii.Animations.KeyframeArray.Clean ( )

inline

        {
            int flag, res, removed = 0;
            KeyframeEntry entry;
 
            //Eliminate redundant values
            for (entry = _keyRoot._next._next; entry != _keyRoot; entry = entry._next)
            {
                flag = res = 0;
 
                if (entry._prev == _keyRoot)
                {
                    if (entry._next != _keyRoot)
                    {
                        flag = 1;
                    }
                }
                else if (entry._next == _keyRoot)
                {
                    flag = 2;
                }
                else
                {
                    flag = 3;
                }
 
                if ((flag & 1) != 0)
                {
                    res |= Math.Abs(entry._next._value - entry._value) <= _cleanDistance ? 1 : 0;
                }
 
                if ((flag & 2) != 0)
                {
                    res |= Math.Abs(entry._prev._value - entry._value) <= _cleanDistance ? 2 : 0;
                }
 
                if (flag == res && res != 0)
                {
                    entry = entry._prev;
                    entry._next.Remove();
 
                    entry.GenerateTangent();
                    entry._next.GenerateTangent();
                    entry._prev.GenerateTangent();
 
                    _keyCount--;
                    removed++;
                }
            }
 
            return removed;
        }

Delete()

void BrawlLib.Wii.Animations.KeyframeArray.Delete ( int  index )

inline

        {
            KeyframeEntry entry = null;
            for (entry = _keyRoot._prev; entry != _keyRoot && entry._index >= index; entry = entry._prev)
            {
                if (entry._index == index || --entry._index < 0)
                {
                    entry = entry._next;
                    entry._prev.Remove();
                    _keyCount--;
                }
            }
        }

Equals()

bool BrawlLib.Wii.Animations.KeyframeArray.Equals ( KeyframeArray  obj )

inline

        {
            if(obj._keyCount != _keyCount)
                return false;
 
            KeyframeEntry comp1 = _keyRoot;
            KeyframeEntry comp2 = obj._keyRoot;
 
            for (int i = 0; i < _keyCount; i++)
            {
                if(!comp1.Equals(comp2))
                    return false;
 
                comp1 = comp1._next;
                comp2 = comp2._next;
            }
 
            return true;
        }

GetFrameValue()

float BrawlLib.Wii.Animations.KeyframeArray.GetFrameValue ( float  index, bool  returnOutValue = false  )

inline

        {
            KeyframeEntry entry;
 
            if (index > _keyRoot._prev._index)
            {
                //If the frame is greater than the last keyframe's frame index
                if (_looped)
                {
                    float span = FrameLimit - _keyRoot._prev._index.Clamp(0, FrameLimit) +
                                 _keyRoot._next._index.Clamp(0, FrameLimit);
                    float offset =
                        index > _keyRoot._prev._index && index < FrameLimit
                            ? index - _keyRoot._prev._index
                            : FrameLimit - _keyRoot._prev._index + index;
 
                    return _keyRoot._prev.Interpolate(offset, span, _keyRoot._next);
                }
 
                return _keyRoot._prev._value;
            }
 
            if (index < _keyRoot._next._index)
            {
                //If the frame is less than the first keyframe's frame index
                if (_looped)
                {
                    float span = FrameLimit - _keyRoot._prev._index.Clamp(0, FrameLimit) +
                                 _keyRoot._next._index.Clamp(0, FrameLimit);
                    float offset =
                        index > _keyRoot._prev._index.Clamp(0, FrameLimit) && index < FrameLimit
                            ? index - _keyRoot._prev._index.Clamp(0, FrameLimit)
                            : FrameLimit - _keyRoot._prev._index.Clamp(0, FrameLimit) + index;
 
                    return _keyRoot._prev.Interpolate(offset, span, _keyRoot._next);
                }
 
                return _keyRoot._next._value;
            }
 
            //Find the entry just before the specified index
            for (entry = _keyRoot._next; //Get the first entry
                entry != _keyRoot &&     //Make sure it's not the root
                entry._index <= index;   //Its index must be less than or equal to the current index
                entry = entry._next)     //Get the next entry
            {
                if (entry._index == index)
                {
                    //The index is a keyframe
                    if (returnOutValue)
                    {
                        while (entry._next != null && entry._next._index == entry._index)
                        {
                            entry = entry._next;
                        }
                    }
 
                    return entry._value; //Return the value of the keyframe.
                }
            }
 
            //Frame lies between two keyframes. Interpolate between them
            return entry._prev.Interpolate(index - entry._prev._index);
        }

GetKeyframe()

KeyframeEntry BrawlLib.Wii.Animations.KeyframeArray.GetKeyframe ( int  index )

inline

        {
            KeyframeEntry entry;
            for (entry = _keyRoot._next; entry != _keyRoot && entry._index < index; entry = entry._next)
            {
                ;
            }
 
            if (entry._index == index)
            {
                return entry;
            }
 
            return null;
        }

Insert()

void BrawlLib.Wii.Animations.KeyframeArray.Insert ( int  index )

inline

        {
            KeyframeEntry entry = null;
            for (entry = _keyRoot._prev; entry != _keyRoot && entry._index >= index; entry = entry._prev)
            {
                if (++entry._index >= _frameLimit)
                {
                    entry = entry._next;
                    entry._prev.Remove();
                    _keyCount--;
                }
            }
        }

Remove()

KeyframeEntry BrawlLib.Wii.Animations.KeyframeArray.Remove ( int  index )

inline

        {
            KeyframeEntry entry = null;
            for (entry = _keyRoot._next; entry != _keyRoot && entry._index < index; entry = entry._next)
            {
                ;
            }
 
            if (entry._index == index)
            {
                entry.Remove();
                _keyCount--;
            }
            else
            {
                entry = null;
            }
 
            return entry;
        }

SetFrameValue()

KeyframeEntry BrawlLib.Wii.Animations.KeyframeArray.SetFrameValue ( int  index, float  value, bool  parsing = false  )

inline

        {
            KeyframeEntry entry = null;
            if (_keyRoot._prev == _keyRoot || _keyRoot._prev._index < index)
            {
                entry = _keyRoot;
            }
            else
            {
                for (entry = _keyRoot._next; entry != _keyRoot && entry._index <= index; entry = entry._next)
                {
                    ;
                }
            }
 
            entry = entry._prev;
            if (entry._index != index)
            {
                _keyCount++;
                entry.InsertAfter(entry = new KeyframeEntry(index, value));
            }
            else
            {
                //There can be up to two keyframes with the same index.
                if (!parsing)
                {
                    entry._value = value; //Do this when editing
                }
                else
                {
                    //And this when parsing
                    _keyCount++;
                    KeyframeEntry temp = new KeyframeEntry(index, value);
                    entry.InsertAfter(temp);
                    entry = temp;
                }
            }
 
            return entry;
        }

Property Documentation

FrameLimit

int BrawlLib.Wii.Animations.KeyframeArray.FrameLimit

getset

        {
            get => _frameLimit;
            set
            {
                _frameLimit = value;
                while (_keyRoot._prev._index >= value)
                {
                    _keyRoot._prev.Remove();
                    _keyCount--;
                }
            }
        }

Loop

bool BrawlLib.Wii.Animations.KeyframeArray.Loop

getset

        {
            get => _looped;
            set => _looped = value;
        }

this[int index]

float BrawlLib.Wii.Animations.KeyframeArray.this[int index]

getset

        {
            get => GetFrameValue(index);
            set => SetFrameValue(index, value);
        }

---

The documentation for this class was generated from the following file:

• BrawlLib/Wii/Animations/KeyframeCollection.cs