BrawlLib.Wii.Animations.KeyframeEntry Class Reference

Public Member Functions
bool	Equals (KeyframeEntry obj)
	KeyframeEntry (int index, float value)
void	InsertBefore (KeyframeEntry entry)
	Inserts the provided entry before this one and relinks the previous and next entries. More...
void	InsertAfter (KeyframeEntry entry)
	Inserts the provided entry after this one and relinks the previous and next entries. More...
void	Remove ()
float	Interpolate (float offset, float span, KeyframeEntry next, bool forceLinear=false)
float	Interpolate (float offset, bool forceLinear=false)
	Returns an interpolated value between this keyframe and the next. You can force linear calculation, but the Wii itself doesn't have anything like that. The Wii emulates linear interpolation using two keyframes across a range with the same tangent and then two keyframes on the same frame but with different tangents. More...
float	GenerateTangent ()
override string	ToString ()

Public Attributes
int	_index
KeyframeEntry	_prev
KeyframeEntry	_next
float	_value
float	_tangent

Properties
KeyframeEntry	Second [get, set]

Constructor & Destructor Documentation

KeyframeEntry()

BrawlLib.Wii.Animations.KeyframeEntry.KeyframeEntry ( int  index, float  value  )

inline

        {
            _index = index;
            _prev = _next = this;
            _value = value;
        }

Member Function Documentation

Equals()

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

inline

        {
            return obj is KeyframeEntry entry && _index == entry._index && _value == entry._value && _tangent == entry._tangent;
        }

GenerateTangent()

float BrawlLib.Wii.Animations.KeyframeEntry.GenerateTangent ( )

inline

        {
            _tangent = 0.0f;
            if (Second != null)
            {
                if (_prev._index == _index)
                {
                    if (_next._index != -1)
                    {
                        //Generate only with the next keyframe
                        _tangent = (_value - _next._value) / (_index - _next._index);
                    }
                }
                else if (_next._index == _index)
                {
                    if (_prev._index != -1)
                    {
                        //Generate only with the previous keyframe
                        _tangent = (_value - _prev._value) / (_index - _prev._index);
                    }
                }
            }
            else
            {
                float weightCount = 0;
                if (_prev._index != -1)
                {
                    _tangent += (_value - _prev._value) / (_index - _prev._index);
                    weightCount++;
                }
 
                if (_next._index != -1)
                {
                    _tangent += (_next._value - _value) / (_next._index - _index);
                    weightCount++;
                }
 
                if (weightCount > 0)
                {
                    _tangent /= weightCount;
                }
            }
 
            if (RoundTangent)
            {
                _tangent = (float) Math.Round(_tangent, TangetDecimalPlaces);
            }
 
            return _tangent;
        }

InsertAfter()

void BrawlLib.Wii.Animations.KeyframeEntry.InsertAfter ( KeyframeEntry  entry )

inline

Inserts the provided entry after this one and relinks the previous and next entries.

        {
            _next._prev = entry;
            entry._next = _next;
            entry._prev = this;
            _next = entry;
        }

InsertBefore()

void BrawlLib.Wii.Animations.KeyframeEntry.InsertBefore ( KeyframeEntry  entry )

inline

Inserts the provided entry before this one and relinks the previous and next entries.

        {
            _prev._next = entry;
            entry._prev = _prev;
            entry._next = this;
            _prev = entry;
        }

Interpolate() [1/2]

float BrawlLib.Wii.Animations.KeyframeEntry.Interpolate ( float  offset, bool  forceLinear = false  )

inline

Returns an interpolated value between this keyframe and the next. You can force linear calculation, but the Wii itself doesn't have anything like that. The Wii emulates linear interpolation using two keyframes across a range with the same tangent and then two keyframes on the same frame but with different tangents.

        {
            return Interpolate(offset, _next._index - _index, _next, forceLinear);
        }

Interpolate() [2/2]

float BrawlLib.Wii.Animations.KeyframeEntry.Interpolate ( float  offset, float  span, KeyframeEntry  next, bool  forceLinear = false  )

inline

        {
            //Return this value if no offset from this keyframe
            if (offset == 0)
            {
                return _value;
            }
 
            //Return next value if offset is to the next keyframe
            if (offset == span)
            {
                return next._value;
            }
 
            //Get the difference in values
            float diff = next._value - _value;
 
            //Calculate a percentage from this keyframe to the next
            float time = offset / span; //Normalized, 0 to 1
 
            bool prevDouble = _prev._index >= 0 && _prev._index == _index - 1;
            bool nextDouble = next._next._index >= 0 && next._next._index == next._index + 1;
            bool oneApart = _next._index == _index + 1;
 
            if (forceLinear)
            {
                return _value + diff * time;
            }
 
            float tan = _tangent;
            float nextTan = next._tangent;
 
            if (prevDouble || oneApart)
            {
                // Do nothing, as this doesn't seem to work properly //tan = (next._value - _value) / (next._index - _index);
            }
 
            if (nextDouble || oneApart)
            {
                // Do nothing, as this doesn't seem to work properly //nextTan = (next._value - _value) / (next._index - _index);
            }
 
            //Interpolate using a hermite curve
            float inv = time - 1.0f; //-1 to 0
            return _value
                   + offset * inv * (inv * tan + time * nextTan)
                   + time * time * (3.0f - 2.0f * time) * diff;
        }

Remove()

void BrawlLib.Wii.Animations.KeyframeEntry.Remove ( )

inline

        {
            _next._prev = _prev;
            _prev._next = _next;
        }

ToString()

override string BrawlLib.Wii.Animations.KeyframeEntry.ToString ( )

inline

        {
            return $"Value={_value}";
        }

Member Data Documentation

_index

int BrawlLib.Wii.Animations.KeyframeEntry._index

_next

KeyframeEntry BrawlLib.Wii.Animations.KeyframeEntry._next

_prev

KeyframeEntry BrawlLib.Wii.Animations.KeyframeEntry._prev

_tangent

float BrawlLib.Wii.Animations.KeyframeEntry._tangent

_value

float BrawlLib.Wii.Animations.KeyframeEntry._value

Property Documentation

Second

KeyframeEntry BrawlLib.Wii.Animations.KeyframeEntry.Second

getset

        {
            get => _prev._index == _index ? _prev : _next._index == _index ? _next : null;
            set
            {
                KeyframeEntry second = Second;
                if (second == null)
                {
                    value._index = _index;
                    InsertAfter(value);
                }
                else
                {
                    second._value = value._value;
                    second._tangent = value._tangent;
                }
            }
        }

---

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

• BrawlLib/Wii/Animations/KeyframeCollection.cs