protected override async Task Act(ActParameters Parameters)
{
bool Success = true;
var context = InitializeContext(Parameters, ref Success);
if (!Success)
{
Debug.LogWarning("Animation initialization failed.", this);
return;
}
var target = ConvertData(Target);
if (Duration <= 0)
{
Set(ref context, target);
return;
}
float Speed = 1 / Duration;
var start = EvaluateStartPoint(ref context);
for (float t = 0; t < 1; t += Time.deltaTime * Speed)
{
Set(ref context, Lerp(
start,
target,
Interpolators.Interpolate(InterpolationType, t)
));
await Parameters.Yield();
}
Set(ref context, target);
}
private bool ensureInterpolator()
{
if (this.Interpolator == null)
{
this.Interpolator = Interpolators.Get <T>();
}
return(this.Interpolator != null);
}
protected void OnDestroy()
{
this._destroying = true;
if (this._running)
{
Interpolators.SetDisabled(this);
this._running = false;
}
}
public PricingResults Results(OptionInstrument option, PricingConfiguration pricingcfg)
{
var blackModel = new BlackModelOption();
double riskfacor = Interpolators.InterpolateForward(option.SousJacent, option.RiskFactorDate);
double price = blackModel.PriceBlackModel(option, riskfacor);
var resultGreeks = blackModel.ComputeGreeks(pricingcfg.GreeksToCompute, riskfacor, option);
return(new PricingResults(resultGreeks, price));
}
/// <summary>
/// Performs a linear interpolation between the specified values.
/// </summary>
/// <typeparam name="T">The type of value to tween.</typeparam>
/// <param name="lerpStart">The start value.</param>
/// <param name="lerpEnd">The end value.</param>
/// <param name="t">A value between 0.0 and 1.0 indicating the current position in the interpolation.</param>
/// <returns>A value which is interpolated from the specified start and end values.</returns>
public static T LerpRef <T>(ref T lerpStart, ref T lerpEnd, Single t) where T : struct
{
Interpolator <T> interpolator;
if (!Interpolators.TryGet <T>(out interpolator) || interpolator == null)
{
return((T)Tween(lerpStart, (Object)lerpEnd, Easings.EaseInLinear, t));
}
return(interpolator(lerpStart, lerpEnd, Easings.EaseInLinear, t));
}
/// <summary>
/// Tweens the specified values.
/// </summary>
/// <typeparam name="T">The type of value to tween.</typeparam>
/// <param name="tweenStart">The start value.</param>
/// <param name="tweenEnd">The end value.</param>
/// <param name="fn">The easing function to apply.</param>
/// <param name="t">A value between 0.0 and 1.0 indicating the current position in the tween.</param>
/// <returns>A value which is interpolated from the specified start and end values.</returns>
public static T TweenRef <T>(ref T tweenStart, ref T tweenEnd, EasingFunction fn, Single t) where T : struct
{
Interpolator <T> interpolator;
if (!Interpolators.TryGet <T>(out interpolator) || interpolator == null)
{
return((T)Tween(tweenStart, (Object)tweenEnd, fn, t));
}
return(interpolator(tweenStart, tweenEnd, fn, t));
}
private void OnDrawGizmos()
{
int numSamples = 10;
for (int i = 0; i < numSamples; i++)
{
float ratio = Interpolators.bounceInOut(0, 1, (float)i / (float)numSamples);
Gizmos.DrawWireSphere(Vector3.Lerp(startingPoint,
transformations[0].position, ratio), 0.1f);
}
}
// Update is called once per frame
void Update()
{
float ratio = Interpolators.expoOut(0, 1, t);
transform.position = Vector3.Lerp(startingPoint,
transformations[actualId].position, ratio);
t += Time.deltaTime;
if (t >= 1.0f)
{
actualId++;
actualId %= transformations.Length;
t = 0.0f;
}
}
public ImageProcessor(System.Drawing.Bitmap bitmap, double width, double height, double lineRes, double pointRes, double angle, Interpolators.IInterpolator interpolator)
{
if (width < 0)
throw new Exception("Width can not be negative");
if (height < 0)
throw new Exception("Height can not be negative");
if (lineRes < 0)
throw new Exception("lineRes can not be negative");
if (pointRes < 0)
throw new Exception("pointRes can not be negative");
_Angle = angle;
_PointRes = pointRes;
_LineRes = lineRes;
_Height = height;
_Width = width;
_image = new Image(width, height, bitmap, interpolator);
}
/// <summary>
/// Initializes the <see cref="Tweening"/> type.
/// </summary>
static Tweening()
{
Interpolators.Register <Object>(Tween);
Interpolators.Register <Boolean>(Tween);
Interpolators.Register <Byte>(Tween);
Interpolators.Register <SByte>(Tween);
Interpolators.Register <Char>(Tween);
Interpolators.Register <Int16>(Tween);
Interpolators.Register <Int32>(Tween);
Interpolators.Register <Int64>(Tween);
Interpolators.Register <UInt16>(Tween);
Interpolators.Register <UInt32>(Tween);
Interpolators.Register <UInt64>(Tween);
Interpolators.Register <Single>(Tween);
Interpolators.Register <Double>(Tween);
Interpolators.Register <Decimal>(Tween);
Interpolators.RegisterDefault <Color>();
}
//public Image(int width, int height)
//{
// _pixels = new Pixel[width, height];
// for (int x = 0; x < width; x++)
// for (int y = 0; y < height; y++)
// _pixels[x, y] = new Pixel(x, y);
//}
public Image(double width, double height, System.Drawing.Bitmap bitmap, Interpolators.IInterpolator interpolator)
{
if (interpolator == null)
throw new ArgumentNullException("interpolator", "interpolator is null.");
if (bitmap == null)
throw new ArgumentNullException("bitmap", "bitmap is null.");
if (Width < 0)
throw new Exception("Width can't be negative");
if (Height < 0)
throw new Exception("Height can't be negative");
Width = width;
Height = height;
_interpolator = interpolator;
ScaleHorizontal = (bitmap.Width - 1) / Width;
ScaleVertical = (bitmap.Height - 1) / Height;
_pixels = new Pixel[bitmap.Width, bitmap.Height];
for (int x = 0; x < bitmap.Width; x++)
for (int y = 0; y < bitmap.Height; y++)
_pixels[x, y] = new Pixel(bitmap.GetPixel(x, bitmap.Height - y - 1).GetBrightness(), x, y);
}
/// <summary>
/// <para>Returns a Tween<T> object that is configured to animate the named property of the target object.</para>
/// <b>For example, to tween the "timeScale" property of a custom class, you could use the following:</b><pre><code>
/// var tween = TweenProperty<float>
/// .Obtain( target, "timeScale" )
/// .SetStartValue( 0f )
/// .SetEndValue( 1f )
/// .SetDuration( 0.5f );
/// </code></pre>
/// </summary>
/// <param name="target">The object to be animated</param>
/// <param name="propertyName">The name of the property to be animated</param>
public static Tween <T> Obtain(object target, string propertyName)
{
return(Obtain(target, propertyName, Interpolators.Get <T>()));
}
internal static void SyncronizeAll()
{
Interpolators.UpdateAll();
}
