public void Property(FFRef <Color> var, Color endValue, AnimationCurve curve, float timeToComplete = CurveTime)
{
if (timeToComplete == CurveTime)
{
timeToComplete = curve.TimeToComplete();
}
if (_sequence.Count != 0 && var != null)
{
// Set Property
FFActionProperty <Color> myprop = new FFActionProperty <Color>();
myprop.var = var;
myprop.start_value = var.Val;
myprop.end_value = endValue;
myprop.curr_time = 0.0f;
myprop.prev_value = var.Val;
// total_time cannot be zero
myprop.total_time = Mathf.Max(timeToComplete, 0.01f);
SetMuGetter <Color>(myprop, curve);
// Add to front of sequence
if (_sequence[_sequence.Count - 1].as_ColorProperties == null)
{
_sequence[_sequence.Count - 1].as_ColorProperties = new List <FFActionProperty <Color> >();
}
_sequence[_sequence.Count - 1].as_ColorProperties.Add(myprop);
}
else
{
Debug.Log("Error in ActionSequence Property call");
}
}
public void Property(FFRef <Vector4> var, Vector4 endValue, FFEase easeType, float timeToComplete)
{
if (_sequence.Count != 0 && var != null)
{
// Set Property
FFActionProperty <Vector4> myprop = new FFActionProperty <Vector4>();
myprop.var = var;
myprop.start_value = var.Val;
myprop.end_value = endValue;
myprop.curr_time = 0.0f;
myprop.prev_value = var.Val;
// total_time cannot be zero
myprop.total_time = Mathf.Max(timeToComplete, 0.01f);
SetMuGetter <Vector4>(myprop, easeType);
// Add to front of sequence
if (_sequence[_sequence.Count - 1].as_Vector4Properties == null)
{
_sequence[_sequence.Count - 1].as_Vector4Properties = new List <FFActionProperty <Vector4> >();
}
_sequence[_sequence.Count - 1].as_Vector4Properties.Add(myprop);
}
else
{
Debug.Log("Error in ActionSequence Property call");
}
}
private static bool FFActionUpdaterColor(FFActionProperty <Color> prop, float dt)
{
bool incomplete = true;
// Add dt
prop.curr_time = dt + prop.curr_time;
if (prop.curr_time >= prop.total_time)
{
prop.curr_time = prop.total_time;
incomplete = false;
}
float mu = prop.mu_getter(prop.curr_time, prop.total_time);
Color next_value = (prop.start_value * (1 - mu) + prop.end_value * mu);
// added delta if any
Color curr_value = prop.var.Val;
prop.var.Setter(new Color(
next_value.r - prop.prev_value.r + curr_value.r,
next_value.g - prop.prev_value.g + curr_value.g,
next_value.b - prop.prev_value.b + curr_value.b,
next_value.a - prop.prev_value.a + curr_value.a));
prop.prev_value = new Color(next_value.r, next_value.g, next_value.b, next_value.a);
return(incomplete);
}
// Un-Tested
private static bool FFActionUpdaterVector4(FFActionProperty <Vector4> prop, float dt)
{
bool incomplete = true;
// Add dt
prop.curr_time = dt + prop.curr_time;
if (prop.curr_time >= prop.total_time)
{
prop.curr_time = prop.total_time;
incomplete = false;
}
float mu = prop.mu_getter(prop.curr_time, prop.total_time);
Vector4 next_value = (prop.start_value * (1 - mu) + prop.end_value * mu);
// added delta if any
Vector4 curr_value = prop.var.Val;
prop.var.Setter(new Vector4(
next_value.x - prop.prev_value.x + curr_value.x,
next_value.y - prop.prev_value.y + curr_value.y,
next_value.z - prop.prev_value.z + curr_value.z,
next_value.w - prop.prev_value.w + curr_value.w));
prop.prev_value.Set(next_value.x, next_value.y, next_value.z, next_value.w);
return(incomplete);
}
private static void SetMuGetter <T>(FFActionProperty <T> prop, AnimationCurve curve)
{
var firstKeyTime = curve.keys[0].time;
if (firstKeyTime < 0)
{
var keys = curve.keys;
for (int i = 0; i < curve.keys.Length; ++i)
{
keys[i].time += (-firstKeyTime);
}
curve.keys = keys;
}
prop.mu_getter = (curr_time, total_time) => curve.Evaluate((curr_time / total_time) * curve.keys[curve.keys.Length - 1].time);
}
private static void SetMuGetter <T>(FFActionProperty <T> prop, AnimationCurve curve)
{
Debug.Assert(curve.length > 1, "Using animation curves for FFAction.Property(...) Must have atleast 2 points");
var firstKeyTime = curve.keys[0].time;
if (firstKeyTime < 0)
{
var keys = curve.keys;
for (int i = 0; i < curve.keys.Length; ++i)
{
keys[i].time += (-firstKeyTime);
}
curve.keys = keys;
}
prop.mu_getter = (curr_time, total_time) => curve.Evaluate((curr_time / total_time) * curve.keys[curve.keys.Length - 1].time);
}
// FFActionUpdaters (Interpolation logic)
#region FFActionUpdaters
// Un-tested
private static bool FFActionUpdaterInt(FFActionProperty <int> prop, float dt)
{
bool incomplete = true;
// Add dt
prop.curr_time = dt + prop.curr_time;
if (prop.curr_time >= prop.total_time)
{
prop.curr_time = prop.total_time;
incomplete = false;
}
float mu = prop.mu_getter(prop.curr_time, prop.total_time);
int next_value = (int)(prop.start_value * (1 - mu) + prop.end_value * mu);
// added delta if any
prop.var.Val = next_value - prop.prev_value + prop.var.Val;
prop.prev_value = next_value;
return(incomplete);
}
// MuGetters for Calculators and Animation Curves
#region MuGetters
private static void SetMuGetter <T>(FFActionProperty <T> prop, FFEase ease)
{
// E_SmoothStart
if ((FFEase.E_SmoothStart & ease).Equals(FFEase.E_SmoothStart))
{
prop.mu_getter = GetMuSmoothStart;
}
// E_SmoothEnd
else if ((FFEase.E_SmoothEnd & ease).Equals(FFEase.E_SmoothEnd))
{
prop.mu_getter = GetMuSmoothEnd;
}
// E_SmoothStartEnd
else if ((FFEase.E_SmoothStartEnd & ease).Equals(FFEase.E_SmoothStartEnd))
{
prop.mu_getter = GetMuSmoothStartEnd;
}
else //default E_Continuous
{
prop.mu_getter = GetMuContinuous;
}
}
