internal static void UpdateAnimation(ref EvaluatorData animationChannel, ref KeyFrameData <float> animationValue)
{
animationChannel.ValuePrev = animationChannel.ValueStart;
animationChannel.ValueStart = animationChannel.ValueEnd;
animationChannel.ValueEnd = animationChannel.ValueNext;
animationChannel.ValueNext = animationValue;
}
internal static void InitializeAnimation(ref EvaluatorData animationChannel, ref AnimationInitialValues <float> animationValue)
{
animationChannel.ValuePrev = animationValue.Value1;
animationChannel.ValueStart = animationValue.Value1;
animationChannel.ValueEnd = animationValue.Value1;
animationChannel.ValueNext = animationValue.Value2;
}
public float EvaluateCubic(CompressedTimeSpan time)
{
int keyIndex;
for (keyIndex = 0; keyIndex < KeyFrames.Count - 1; ++keyIndex)
{
if (time < KeyFrames[keyIndex + 1].Time)
{
break;
}
}
// TODO: Check if before or after curve (and on those limits)
// Exact value, just returns it.
if (time == KeyFrames[keyIndex].Time)
{
return(KeyFrames[keyIndex].Value);
}
// http://en.wikipedia.org/wiki/Cubic_Hermite_spline#Interpolation_on_the_unit_interval_without_exact_derivatives
long timeStart = KeyFrames[keyIndex + 0].Time.Ticks;
long timeEnd = KeyFrames[keyIndex + 1].Time.Ticks;
float t = ((float)time.Ticks - (float)timeStart) / ((float)timeEnd - (float)timeStart);
var evaluator = new EvaluatorData();
evaluator.ValuePrev = KeyFrames[keyIndex > 0 ? keyIndex - 1 : 0];
evaluator.ValueStart = KeyFrames[keyIndex + 0];
evaluator.ValueEnd = KeyFrames[keyIndex + 1];
evaluator.ValueNext = KeyFrames[keyIndex + 2 < KeyFrames.Count ? keyIndex + 2 : KeyFrames.Count - 1];
return(evaluator.Evaluate(t));
}
public LazyItemOperation(OperationBuilder builder, LazyItemEvaluator <P, I, M, D> lazyEvaluator)
{
_itemElement = builder.ItemElement;
_itemType = builder.ItemType;
_operations = builder.Operations.ToImmutable();
_referencedItemLists = builder.ReferencedItemLists.ToImmutable();
_lazyEvaluator = lazyEvaluator;
_evaluatorData = new EvaluatorData(_lazyEvaluator._outerEvaluatorData, itemType => GetReferencedItems(itemType, ImmutableHashSet <string> .Empty));
_expander = new Expander <P, I>(_evaluatorData, _evaluatorData);
_itemFactory = new ItemFactoryWrapper(_itemElement, _lazyEvaluator._itemFactory);
}
protected LazyItemOperation(OperationBuilder builder, LazyItemEvaluator <P, I, M, D> lazyEvaluator)
{
_itemElement = builder.ItemElement;
_itemType = builder.ItemType;
_itemSpec = builder.ItemSpec;
_referencedItemLists = builder.ReferencedItemLists.ToImmutable();
_conditionResult = builder.ConditionResult;
_lazyEvaluator = lazyEvaluator;
_evaluatorData = new EvaluatorData(_lazyEvaluator._outerEvaluatorData, itemType => GetReferencedItems(itemType, ImmutableHashSet <string> .Empty));
_itemFactory = new ItemFactoryWrapper(_itemElement, _lazyEvaluator._itemFactory);
_expander = new Expander <P, I>(_evaluatorData, _evaluatorData, _lazyEvaluator.EvaluationContext);
_itemSpec.Expander = _expander;
}
