public override void ApplyInterpolation(ActorComponent component, float time, KeyFrame toFrame, float mix)
{
switch (m_InterpolationType)
{
case KeyFrame.InterpolationTypes.Mirrored:
case KeyFrame.InterpolationTypes.Asymmetric:
case KeyFrame.InterpolationTypes.Disconnected:
{
ValueTimeCurveInterpolator interpolator = m_Interpolator as ValueTimeCurveInterpolator;
if (interpolator != null)
{
float v = (float)interpolator.Get((double)time);
SetValue(component, v, mix);
}
break;
}
case KeyFrame.InterpolationTypes.Hold:
{
SetValue(component, m_Value, mix);
break;
}
case KeyFrame.InterpolationTypes.Linear:
{
KeyFrameNumeric to = toFrame as KeyFrameNumeric;
float f = (time - m_Time) / (to.m_Time - m_Time);
SetValue(component, m_Value * (1.0f - f) + to.m_Value * f, mix);
break;
}
}
}
public static KeyFrame Read(BinaryReader reader, ActorComponent component)
{
KeyFrameConstraintStrength frame = new KeyFrameConstraintStrength();
if (KeyFrameNumeric.Read(reader, frame))
{
return(frame);
}
return(null);
}
public static KeyFrame Read(BinaryReader reader, ActorComponent component)
{
KeyFrameOpacity frame = new KeyFrameOpacity();
if (KeyFrameNumeric.Read(reader, frame))
{
return(frame);
}
return(null);
}
public override bool SetNextFrame(KeyFrameWithInterpolation frame, KeyFrame nextFrame)
{
// This frame is a hold, return false to remove the interpolator.
// We store it in the first place as when it gets called as the nextFrame parameter (in a previous call)
// we still read out the in factor and in value (see below where nextInValue and nextInFactor are defined).
if (frame.InterpolationType == KeyFrame.InterpolationTypes.Hold)
{
return(false);
}
// Just a sanity check really, both keyframes need to be numeric.
KeyFrameNumeric ourFrame = frame as KeyFrameNumeric;
KeyFrameNumeric next = nextFrame as KeyFrameNumeric;
if (ourFrame == null || next == null)
{
return(false);
}
// We are not gauranteed to have a next interpolator (usually when the next keyframe is linear).
ValueTimeCurveInterpolator nextInterpolator = null;
float timeRange = next.Time - ourFrame.Time;
float outTime = (float)(ourFrame.Time + timeRange * m_OutFactor);
float nextInValue = 0.0f;
double nextInFactor = 0.0f;
// Get the invalue and infactor from the next interpolator (this is where hold keyframes get their interpolator values processed too).
if ((nextInterpolator = next.Interpolator as ValueTimeCurveInterpolator) != null)
{
nextInValue = nextInterpolator.m_InValue;
nextInFactor = nextInterpolator.m_InFactor;
//this._Curve = new BezierAnimationCurve([this._Time, this._Value], [outTime, this._OutValue], [inTime, nxt._InValue], [nxt._Time, nxt._Value]);
}
else
{
// Happens when next is linear.
nextInValue = next.Value;
}
float inTime = (float)(next.Time - timeRange * nextInFactor);
// Finally we can generate the curve.
InitializeCurve(ourFrame.Time, ourFrame.Value, outTime, m_OutValue, inTime, nextInValue, next.Time, next.Value);
//this._Curve = new BezierAnimationCurve([ourFrame.Time, ourFrame.Value], [outTime, m_OutValue], [inTime, nextInValue], [next.Time, next.Value]);
return(true);
}
public static bool Read(BinaryReader reader, KeyFrameNumeric frame)
{
if (!KeyFrameWithInterpolation.Read(reader, frame))
{
return(false);
}
frame.m_Value = reader.ReadSingle();
/*if(frame.m_Interpolator != null)
* {
* // TODO: in the future, this could also be a progression curve.
* ValueTimeCurveInterpolator vtci = frame.m_Interpolator as ValueTimeCurveInterpolator;
* if(vtci != null)
* {
* vtci.SetKeyFrameValue(m_Value);
* }
* }*/
return(true);
}
