public override void InterpolateBetweenAndExecute(GenericInstruction otherInstruction, float thisRatio)
{
IInterpolator <ValueType> interpolator = InstructionManager.GetInterpolator(mValue.GetType(), mMember) as
IInterpolator <ValueType>;
ValueType interpolatedValue = interpolator.Interpolate(mValue,
((ValueType)otherInstruction.MemberValueAsObject),
thisRatio);
LateBinder <TargetType> .Instance.SetProperty <ValueType>(mTarget, mMember, interpolatedValue);
}
public GenericInstruction ToInstruction(object target)
{
// Get the type of the property. It could be null so can't do Value.GetType()
Type typeOfTarget = target.GetType();
MemberInfo[] memberInfos = typeOfTarget.GetMember(Member);
Type typeOfMember = null;
FieldInfo fieldInfo = typeOfTarget.GetField(Member);
if (fieldInfo != null)
{
typeOfMember = fieldInfo.FieldType;
}
if (typeOfMember == null)
{
PropertyInfo propertyInfo = typeOfTarget.GetProperty(Member);
typeOfMember = propertyInfo.PropertyType;
}
Type t = typeof(Instruction <, >).MakeGenericType(
target.GetType(),
typeOfMember);
#if WINDOWS_8 || UWP
ConstructorInfo ctor = t.GetConstructor(
new Type[] { target.GetType(), typeof(string), typeOfMember, typeof(double) });
#else
ConstructorInfo ctor = t.GetConstructor(
BindingFlags.Instance | BindingFlags.Public,
null,
new Type[] { target.GetType(), typeof(string), typeOfMember, typeof(double) },
null);
#endif
GenericInstruction instruction = (GenericInstruction)ctor.Invoke(
new Object[] {
target,
Member,
Value,
Time
}
);
return(instruction);
}
public Instruction After(double time)
{
Instruction toReturn;
if (mSetOrCall == SetOrCall.Set)
{
Type memberType = GetMemberType(MemberToSet);
Type instructionType = typeof(Instruction <,>).MakeGenericType(typeof(T), memberType);
GenericInstruction instruction = (GenericInstruction)Activator.CreateInstance(instructionType);
instruction.TimeToExecute = TimeManager.CurrentTime + time;
instruction.SetTarget(Caller);
instruction.Member = MemberToSet;
instruction.MemberValueAsObject = ValueToSet;
toReturn = instruction;
}
else if (ActionT != null)
{
DelegateInstruction <T> delegateInstruction = new DelegateInstruction <T>(ActionT, Caller);
delegateInstruction.TimeToExecute = TimeManager.CurrentTime + time;
toReturn = delegateInstruction;
}
else
{
DelegateInstruction delegateInstruction = new DelegateInstruction(Action);
delegateInstruction.TimeToExecute = TimeManager.CurrentTime + time;
toReturn = delegateInstruction;
}
Caller.Instructions.Add(toReturn);
return(toReturn);
}
public abstract void InterpolateBetweenAndExecute(GenericInstruction otherInstruction, float thisRatio);
public InstructionList CreateVelocityListAtIndex(int keyframeIndex)
{
if (keyframeIndex > Count - 1)
{
// The user passed either the last instruction index or an out-of-bounds index,
// so return an empty list.
return(new InstructionList(0));
}
else
{
#region Get keyframeAtIndex and keyframeAfter
InstructionList keyframeAtIndex = this[keyframeIndex];
InstructionList keyframeAfter = null;
double timeBetween;
if (keyframeIndex == Count - 1)
{
// If it's the last keyframe, use the same keyframe to stop all velocity
keyframeAfter = keyframeAtIndex;
timeBetween = 1; // To prevent NaN values
}
else
{
keyframeAfter = this[keyframeIndex + 1];
timeBetween = keyframeAfter[0].TimeToExecute - keyframeAtIndex[0].TimeToExecute;
}
#endregion
InstructionList instructionList = new InstructionList();
#region Loop through all instructions and create interpolation instructions
for (int i = 0; i < keyframeAtIndex.Count; i++)
{
Instruction instructionAtIndex = keyframeAtIndex[i];
GenericInstruction instructionAtIndexAsGeneric = instructionAtIndex as GenericInstruction;
Type typeOfTarget = instructionAtIndexAsGeneric.Target.GetType();
bool shouldInterpolate =
instructionAtIndexAsGeneric.MemberValueAsObject != null &&
instructionAtIndexAsGeneric != null &&
InstructionManager.HasInterpolatorForType(
instructionAtIndexAsGeneric.MemberValueAsObject.GetType());
string velocityMemberName = InstructionManager.GetVelocityForState(
instructionAtIndexAsGeneric.Member);
if (shouldInterpolate && !string.IsNullOrEmpty(velocityMemberName))
{
Type typeOfValue = instructionAtIndexAsGeneric.MemberValueAsObject.GetType();
//bool hasInterpolated = false;
GenericInstruction instructionAfterAsGeneric = keyframeAfter[i] as GenericInstruction;
if (instructionAfterAsGeneric != null &&
instructionAtIndexAsGeneric.Target == instructionAfterAsGeneric.Target &&
instructionAtIndexAsGeneric.Member == instructionAfterAsGeneric.Member)
{
// We've found the instruction! Create a velocity instruction
Instruction instruction = CreateInstructionFor(
instructionAtIndexAsGeneric.Target,
velocityMemberName,
instructionAtIndexAsGeneric.MemberValueAsObject,
instructionAfterAsGeneric.MemberValueAsObject,
timeBetween,
instructionAtIndexAsGeneric.TimeToExecute,
typeOfTarget,
typeOfValue);
instruction.TimeToExecute = instructionAtIndex.TimeToExecute;
instructionList.Add(instruction);
}
}
// switch on the Type, but can't use a Switch statement
}
#endregion
return(instructionList);
}
}
public void SetState(double time, bool setVelocity)
{
InstructionList keyframeBefore = KeyframeAtOrBefore(time);
InstructionList keyframeAfter = KeyframeAtOrAfter(time);
if (keyframeBefore == null && keyframeAfter == null)
{
return;
}
else if (keyframeBefore == keyframeAfter)
{
keyframeBefore.Execute();
}
else if (keyframeBefore != null && keyframeAfter == null)
{
keyframeBefore.Execute();
}
else if (keyframeAfter != null && keyframeBefore == null)
{
keyframeAfter.Execute();
}
else // the two keyframes are not the same, and neither are null
{
double timeAfter = keyframeAfter[0].TimeToExecute;
double timeBefore = keyframeBefore[0].TimeToExecute;
double range = timeAfter - timeBefore;
double ratioAfter = (time - timeBefore) / range;
double ratioBefore = 1 - ratioAfter;
for (int i = 0; i < keyframeBefore.Count; i++)
{
Instruction instructionBefore = keyframeBefore[i];
GenericInstruction instructionBeforeAsGeneric = instructionBefore as GenericInstruction;
object memberValueAsObject = instructionBeforeAsGeneric.MemberValueAsObject;
// DO MORE HERE
bool shouldInterpolate =
instructionBeforeAsGeneric.MemberValueAsObject != null &&
instructionBeforeAsGeneric != null &&
InstructionManager.HasInterpolatorForType(
instructionBeforeAsGeneric.MemberValueAsObject.GetType());
if (shouldInterpolate)
{
bool hasInterpolated = false;
GenericInstruction instructionAfterAsGeneric =
keyframeAfter[i] as GenericInstruction;
if (instructionAfterAsGeneric != null &&
instructionBeforeAsGeneric.Target == instructionAfterAsGeneric.Target &&
instructionBeforeAsGeneric.Member == instructionAfterAsGeneric.Member)
{
// We've found the instruction! Interpolate!
instructionBeforeAsGeneric.InterpolateBetweenAndExecute(instructionAfterAsGeneric, (float)ratioBefore);
hasInterpolated = true;
}
if (hasInterpolated == false)
{
// for now, fail. Eventually will want to search the entire KeyframeAfter to see if it
// contains a matching instruction for interpolation
throw new NotImplementedException("The keyframes instructions do not match up. Cannot interpolate.");
}
}
else
{
keyframeBefore[i].Execute();
}
}
}
}
