| public static Ease ( double linearStep, double acceleration, EasingType type ) : float | ||
| linearStep | double | |
| acceleration | double | |
| type | EasingType | |
| return | float | |
private void DrawCurveField(Rect position, SerializedProperty property)
{
Easing target = property.GetValue <Easing> ();
position.x = (position.width - curveFieldHeight) / 2f;
position.width = curveFieldHeight;
EditorGUI.DrawRect(position, Color.gray);
float deltaX_ = 1f / pointNumber;
for (int i = 0; i < pointNumber; i++)
{
float x1 = deltaX_ * i;
float x2 = deltaX_ * (i + 1);
Vector2 point1 = new Vector2(x1, target.Ease(x1));
Vector2 point2 = new Vector2(x2, target.Ease(x2));
point1 *= curveFieldHeight;
point1.x += position.x;
point1.y = position.y + curveFieldHeight - point1.y;
point2 *= curveFieldHeight;
point2.x += position.x;
point2.y = position.y + curveFieldHeight - point2.y;
Handles.color = Color.red;
Handles.DrawLine(point1, point2);
}
}
}//end of FSCallBack
void Update () {
if(state == FSState.idle) return;
float u = (Time.time - timeStart);
float uC = Easing.Ease (u, easingCurve);
if (u < 0) {
state = FSState.pre;
transform.position = bezierPts [0];
}//end of if
else {
if (u >= 1) {
uC = 1;
state = FSState.post;
if (reportFinishTo != null) {
reportFinishTo.SendMessage ("FSCallback", this);
Destroy (gameObject);
}//end of second nested if
else {
state = FSState.idle;
}//end of second nested else
}//end of nested if
else {
state = FSState.active;
}//end of nested else
}//end of else
Vector3 pos = Utils.Bezier(uC, bezierPts);
transform.position = pos;
if (fontSizes != null && fontSizes.Count > 0) {
int size = Mathf.RoundToInt (Utils.Bezier (uC, fontSizes));
GetComponent<GUIText> ().fontSize = size;
}//end of if
}//end of Update
protected override void OnUpdate(float time)
{
var lerpColor = color;
lerpColor.a = Easing.Ease(interpolation, 0, color.a, GetClipWeight(time));
DirectorGUI.UpdateOverlayText(text, lerpColor, size, anchor, position);
}
public override IObservable <IBrush> DoTransition(IObservable <double> progress, IBrush oldValue, IBrush newValue)
{
// This strange behavior occurs on every application shutdown with alternating null values for a few calls.
if (oldValue is null || newValue is null)
{
return(progress.Select(p => new SolidColorBrush(default(Color))));
}
if (oldValue is not ISolidColorBrush oldBrush)
{
throw new ArgumentException("Only instances of ISolidColorBrush are supported", nameof(oldValue));
}
if (newValue is not ISolidColorBrush newBrush)
{
throw new ArgumentException("Only instances of ISolidColorBrush are supported", nameof(newValue));
}
Color oldColor = oldBrush.Color;
Color newColor = newBrush.Color;
return(progress.Select(p =>
{
double e = Easing.Ease(p);
int A = (int)(e * (newColor.A - oldColor.A) + 0.5) + oldColor.A;
int R = (int)(e * (newColor.R - oldColor.R) + 0.5) + oldColor.R;
int G = (int)(e * (newColor.G - oldColor.G) + 0.5) + oldColor.G;
int B = (int)(e * (newColor.B - oldColor.B) + 0.5) + oldColor.B;
return new SolidColorBrush(new Color((byte)A, (byte)R, (byte)G, (byte)B));
}));
}
protected override void OnUpdate(float deltaTime)
{
var lerpColor = color;
lerpColor.a = Easing.Ease(interpolation, 0, color.a, GetClipWeight(deltaTime));
DirectorGUI.UpdateSubtitles(text, lerpColor);
}
protected override void OnUpdate(float deltaTime)
{
var lerpColor = color;
lerpColor.a = Easing.Ease(interpolation, 0, color.a, GetClipWeight(deltaTime));
DirectorGUI.UpdateOverlayImage(texture, lerpColor, scale, position);
}
// Compare two Shots. 1 is a perfect match, while <0 is not valid
public static float Compare(Shot target, Shot test)
{
// Get the postional deviation of both the camera and the Raycast hit
float posDev = (test.position - target.position).magnitude;
float tarDev = (test.target - target.target).magnitude;
float posAccPct, tarAccPct, posAP2, tarAP2; // Accuracy percentages
TargetCamera tc = TargetCamera.S;
// Get a value for accuracy where 1 is perfect and 0 is barely okay
posAccPct = 1 - (posDev / tc.maxPosDeviation);
tarAccPct = 1 - (tarDev / tc.maxTarDeviation);
// Curve the value so that it's more forgiving. This uses the same
// Easing that we do for motion. You can curve ANY value between
// 0 and 1, not just Interpolation values.
posAP2 = Easing.Ease(posAccPct, tc.deviationEasing);
tarAP2 = Easing.Ease(tarAccPct, tc.deviationEasing);
float accuracy = (posAP2 + tarAP2) / 2f;
// Remember that you can use Utills to format numbers nicely as strings
string accText = Utils.RoundToPlaces(accuracy * 100).ToString() + "%";
Utils.tr("Position:", posAccPct, posAP2, "Target:", tarAccPct, tarAP2, "Accuracy:", accText);
return(accuracy);
}
void Update()
{
if (!Enabled || _target == null || _target.Destroyed)
{
return;
}
var targetLocalPos = parent.InverseTransformPoint(_target.Pos);
var nextPos = targetLocalPos + _offset;
SetXY(nextPos.x, nextPos.y);
_shadowText.EasyDraw.alpha = this.EasyDraw.alpha;
if (_isFading && _offSetAnimTimer <= _fadeInOutDuration)
{
float xPos = _offsetAnim.x * Easing.Ease(Easing.Equation.QuadEaseOut, _offSetAnimTimer, 0, 1, _fadeInOutDuration);
float yPos = _offsetAnim.y * Easing.Ease(Easing.Equation.QuadEaseOut, _offSetAnimTimer, 0, 1, _fadeInOutDuration);
SetXY(nextPos.x + xPos, nextPos.y + yPos);
_offSetAnimTimer += Time.deltaTime;
}
if (Input.GetKeyDown(Key.L))
{
Show(100);
}
}
void Animate()
{
rt = 0f;
StartCoroutine(Easing.Ease(duration, Easing.Quadratic.Out, (float t) => {
rt = t;
}, 0f, 1f));
}
// Сравниваем два снимка. 1 - идеально подходит, <0 не подходит
public static float Compare(Shot target, Shot test)
{
// Считаем отклонение камеры и удара от Raycast
float posDev = (test.position - target.position).magnitude;
float tarDev = (test.target - target.target).magnitude;
float posAccPct, tarAccPct, posAP2, tarAP2; // Степень точности
TargetCamera tc = TargetCamera.S;
// Получаем значение точности, где 1 - идеально, 0 - кое как подходит
posAccPct = 1 - (posDev / tc.maxPosDeviation);
tarAccPct = 1 - (tarDev / tc.maxTarDeviation);
// Смягчаем значения чтобы оно было более прощающее
posAP2 = Easing.Ease(posAccPct, tc.deviationEasing);
tarAP2 = Easing.Ease(tarAccPct, tc.deviationEasing);
float accuracy = (posAP2 + tarAP2) / 2f;
// Используем Utils чтобы оформить числа в хорошенькую строку
string accText = Utils.RoundToPlaces(accuracy * 100).ToString() + "%";
Utils.tr("Position:", posAccPct, posAP2, "Target:", tarAccPct, tarAP2, "Accuracy", accuracy);
return(accuracy);
}
void Update()
{
if (!this.Enabled)
{
return;
}
if (_lifeTimeCounter > _lifeTime)
{
//Fall bullet
_isCollisionEnabled = false;
float scale = 0.001f + Easing.Ease(Easing.Equation.QuadEaseIn, _lifeTimeCounter - _lifeTime, 0.999f, 0 - 0.999f, 400);
SetScaleXY(scale, scale);
if (_lifeTimeCounter > _lifeTime + 400)
{
this.SetActive(false);
_isCollisionEnabled = true;
}
}
_lifeTimeCounter += Time.deltaTime;
Move(_speed * Time.delta, 0);
if (MyGame.Debug)
{
DrawBoundBox();
}
}
static IEnumerator TweenSpriteScaleRoutine(GameObject g, Vector2 from, Vector2 to, int duration,
Easing.Equation easing,
int delay = 0, OnFinished onFinished = null)
{
if (delay > 0)
{
yield return(new WaitForMilliSeconds(delay));
}
float durationF = duration * 0.001f;
float time = 0;
g.SetScaleXY(from.x, from.y);
while (time < durationF)
{
float easeVal = Easing.Ease(easing, time, 0, 1, durationF);
float easeValMapX = Mathf.Map(easeVal, 0, 1, from.x, to.x);
float easeValMapY = Mathf.Map(easeVal, 0, 1, from.y, to.y);
float scaleX = easeValMapX;
float scaleY = easeValMapY;
g.SetScaleXY(scaleX, scaleY);
time += Time.delta;
yield return(null);
}
onFinished?.Invoke();
}
private static IEnumerator TweenAlphaRoutine(Sprite sprite, float from, float to, int duration, int delay,
OnTweenComplete onComplete,
Easing.Equation equation)
{
//TODO: remove this call to WaitForMilliSeconds and implement it in the while loop to prevent another instantiation of a yield
if (delay > 0)
{
yield return(new WaitForMilliSeconds(delay));
}
int time = 0;
sprite.alpha = from;
float fromDir = from > to ? from : 0;
float toDir = from > to ? 0 : from;
while (time < duration)
{
sprite.alpha = toDir + Easing.Ease(equation, time, fromDir, to - from, duration);
time += Time.deltaTime;
yield return(null);
}
sprite.alpha = to;
if (onComplete != null)
{
onComplete.Invoke(sprite);
}
}
/// <inheritdocs/>
public override IObservable <double> DoTransition(IObservable <double> progress, double oldValue, double newValue)
{
var delta = newValue - oldValue;
return(progress
.Select(p => Easing.Ease(p) * delta + oldValue));
}
public float GetAxis()
{
if (type == VirtualInputChannelType.Axis)
{
if (isAxisToAxisRemapped)
{
float value = UnInput.GetAxisRaw(name);
if (value < 0)
{
return(-Easing.Ease(axisToAxisRemapType, axisToAxisRemapPhase, -value) * axisToAxisRemapScale);
}
else
{
return(Easing.Ease(axisToAxisRemapType, axisToAxisRemapPhase, value) * axisToAxisRemapScale);
}
}
else
{
return(UnInput.GetAxisRaw(name));
}
}
else if (type == VirtualInputChannelType.Button)
{
if (negName != null)
{
bool pos = UnInput.GetButton(name), neg = UnInput.GetButton(negName);
if (pos ^ neg)
{
return(pos ? buttonToAxisValue : -buttonToAxisValue);
}
else
{
return(0);
}
}
else
{
return(UnInput.GetButton(name) ? buttonToAxisValue : 0);
}
}
else // Key
{
if (negKey != UnKeyCode.None)
{
bool pos = UnInput.GetKey(key), neg = UnInput.GetKey(negKey);
if (pos ^ neg)
{
return(pos ? buttonToAxisValue : -buttonToAxisValue);
}
else
{
return(0);
}
}
else
{
return(UnInput.GetKey(key) ? buttonToAxisValue : 0);
}
}
}
public float GetValue(float time)
{
//Only have one keyframe? Just return it.
if (Data.Length == 1)
{
return(Data [0].Item2);
}
//Locate the keyframes to interpolate between
float t1 = float.NegativeInfinity;
float t2 = 0, v1 = 0, v2 = 0;
for (int i = 0; i < Data.Length - 1; i++)
{
if (time >= Data [i].Item1 && time <= Data [i + 1].Item1)
{
t1 = Data [i].Item1;
t2 = Data [i + 1].Item1;
v1 = Data [i].Item2;
v2 = Data [i + 1].Item2;
break;
}
}
//Time wasn't between any values. Return max.
if (t1 == float.NegativeInfinity)
{
return(Data [Data.Length - 1].Item2);
}
//Interpolate!
return(Easing.Ease(Type, time, t1, t2, v1, v2));
}
/// <inheritdocs/>
public override IObservable <int> DoTransition(IObservable <double> progress, int oldValue, int newValue)
{
var delta = newValue - oldValue;
return(progress
.Select(p => (int)(Easing.Ease(p) * delta + oldValue)));
}
private async Task AnimateAsync(double startValue, double value, Easing easing, int duration, int rate, int animationId)
{
int lastTime = 0;
int i;
for (i = rate; i <= duration; i += rate)
{
await Task.Delay(rate);
var time = (double)i / duration;
var newValue = startValue + easing.Ease(time) * (value - startValue);
if (!UpdateIndicatorValue(newValue, animationId))
{
return;
}
lastTime = i;
}
if (lastTime < duration)
{
await Task.Delay(duration - lastTime);
if (!UpdateIndicatorValue(value, animationId))
{
return;
}
}
Device.BeginInvokeOnMainThread(() =>
{
this.AnimationCompleted?.Invoke(this, EventArgs.Empty);
});
}
public override IObservable <Vector4> DoTransition(IObservable <double> progress, Vector4 oldValue, Vector4 newValue)
{
var delta = newValue - oldValue;
return(progress
.Select(p => (float)Easing.Ease(p) * delta + oldValue));
}
protected override void OnUpdate(float time)
{
var value = Easing.Ease(interpolation, wasSpeed, speed, GetClipWeight(time));
value = Mathf.Clamp(value, 0.01f, 100);
root.playbackSpeed = value;
}
protected override void OnUpdate(float time, float previousTime)
{
if (_PlayOver)
{
return;
}
if (audioClip == null)
{
return;
}
if (source != null && !_PlayLoop)
{
float currentTimeLength = time - clipOffset;
if (currentTimeLength > audioClip.length)
{
_PlayOver = true;
return;
}
var weight = Easing.Ease(EaseType.QuadraticInOut, 0, 1, GetClipWeight(time));
var totalVolume = weight * volume * track.weight;
AudioSampler.Sample(source, audioClip, currentTimeLength, previousTime - clipOffset, totalVolume, track.ignoreTimeScale);
source.panStereo = Mathf.Clamp01(stereoPan + track.stereoPan);
source.loop = _PlayLoop;
if (!string.IsNullOrEmpty(subtitlesText))
{
var lerpColor = subtitlesColor;
lerpColor.a = weight;
DirectorGUI.UpdateSubtitles(string.Format("{0}{1}", parent is ActorAudioTrack? (actor.name + ": ") : "", subtitlesText), lerpColor);
}
}
}
/**
* Metodo invocado una vez por frame. Segun la accion actual, ejecuta el movimiento
* dependiendo del tiempo en el que estamos
**/
public void Update()
{
if (this.isMoving)
{
float u = (1f / timeDuration) * (Time.time - timeStart);
this.transform.position = (1 - u) * this.orgPosition + u * this.poi;
if (u >= 1) //fin del movimiento
{
this.transform.position = this.poi;
isMoving = false; //fin del movimiento
Director.S.Next();
Robot.S.updatePosition();
//this.animationController.setIdle ();
}
}
if (this.isRotating)
{
float u = (Time.time - timeStart) / timeDuration;
this.transform.rotation = Quaternion.Euler((1 - u) * this.orgRotation + u * this.rotPoi);
if (u >= 1)
{
this.transform.rotation = Quaternion.Euler(this.rotPoi);
this.rotAct = this.rotPoi;
isRotating = false; //fin del giro
Director.S.Next();
//this.animationController.setIdle ();
}
}
if (this.isJumping)
{
float u = (Time.time - timeStart) / timeDuration;
// Use Easing class from Utils to curve the u value
float uC = Easing.Ease(u, Easing.InOut);
if (u >= 1) // If u>=1, we're finished moving
{
uC = 1; // Set uC=1 so we don't overshoot
// Move to the final position
transform.position = bezierPts[bezierPts.Count - 1];
this.isJumping = false;
Director.S.Next();
Robot.S.updatePosition();
//this.animationController.setIdle ();
}
else // 0<=u<1, which means that this is interpolating now
// Use Bezier curve to move this to the right point
{
Vector3 pos = Utils.Bezier(uC, bezierPts);
transform.position = pos;
}
}
}
protected override void OnUpdate(float time)
{
if (instance != null)
{
instance.transform.localScale = Easing.Ease(popupInterpolation, Vector3.zero, wasScale, GetClipWeight(time));
}
}
private IEnumerator PlaySmallSmokeRoutine(GameObject parentObj, float px, float py, int duration,
int depthIndex)
{
if (depthIndex < 0)
{
parentObj.AddChild(_smallBlackSmoke00);
}
else
{
parentObj.AddChildAt(_smallBlackSmoke00, depthIndex);
}
_smallBlackSmoke00.visible = true;
_smallBlackSmoke00.SetXY(px, py);
_smallBlackSmoke00.alpha = 1;
float time = 0;
while (time < duration)
{
float fFrame = Mathf.Map(time, 0, duration, 0, _smallBlackSmoke00.frameCount - 1);
int frame = Mathf.Round(fFrame) % _smallBlackSmoke00.frameCount;
_smallBlackSmoke00.alpha = 1 - Easing.Ease(Easing.Equation.CubicEaseIn, time, 0, 1, duration);
_smallBlackSmoke00.SetFrame(frame);
time += Time.deltaTime;
yield return(null);
}
_smallBlackSmoke00.visible = false;
parentObj?.RemoveChild(_smallBlackSmoke00);
}
protected override void OnUpdate(float deltaTime)
{
var color = outColor;
color.a = Easing.Ease(interpolation, 0, 1, GetClipWeight(deltaTime) * fade);
DirectorGUI.UpdateFade(color);
}
protected override void OnUpdate(float time, float previousTime)
{
if (source != null)
{
var weight = Easing.Ease(EaseType.QuadraticInOut, 0, 1, GetClipWeight(time));
var settings = track.sampleSettings;
settings.volume *= weight * volume;
settings.pitch *= pitch;
settings.pan += stereoPan;
AudioSampler.Sample(source, audioClip, time - clipOffset, previousTime - clipOffset, settings);
if (AutoJawSync != null)
{
AutoJawSync.SyncUpdate();
}
if (!string.IsNullOrEmpty(subtitlesText))
{
var lerpColor = subtitlesColor;
lerpColor.a = weight;
DirectorGUI.UpdateSubtitles(string.Format("{0}{1}", parent is ActorAudioTrack ? (actor.name.Replace("(Clone)", "") + ": ") : "", subtitlesText), lerpColor);
}
}
}
protected override void OnUpdate(float time)
{
var value = Easing.Ease(interpolation, wasScale, timeScale, GetClipWeight(time));
value = Mathf.Clamp(value, 0.01f, 100);
Time.timeScale = value;
}
private static IEnumerator TweenIntegerRoutine(IHasTweenInteger tweened, int @from, int to, int duration, int delay, Easing.Equation equation)
{
if (delay > 0)
{
yield return(new WaitForMilliSeconds(delay));
}
int time = 0;
float fromDir = from > to ? from : 0;
float toDir = from > to ? 0 : from;
while (time < duration)
{
tweened.IntValue = Mathf.Round(toDir + Easing.Ease(equation, time, fromDir, to - from, duration));
time += Time.deltaTime;
yield return(null);
}
tweened.IntValue = to;
if (_tweenMap.ContainsKey(tweened))
{
_tweenMap.Remove(tweened);
}
}
// Update is called once per frame
void Update()
{
// If this is not moving, just return
if (state == eFSState.idle)
{
return;
}
// Get u from the current time and duration
// u ranges from 0 to 1 (usually)
float u = (Time.time - timeStart) / timeDuration;
// Use Easing class from Utils to curve the u value
float uC = Easing.Ease(u, easingCurve);
if (u < 0)
{ // If u<0, then we shouldn't move yet.
state = eFSState.pre;
txt.enabled = false; // Hide the score initially
}
else
{
if (u >= 1)
{ // If u>=1, we're done moving
uC = 1; // Set uC=1 so we don't overshoot
state = eFSState.post;
if (reportFinishTo != null)
{ //If there's a callback GameObject
// Use SendMessage to call the FSCallback method
// with this as the parameter.
reportFinishTo.SendMessage("FSCallback", this);
// Now that the message has been sent,
// Destroy this gameObject
Destroy(gameObject);
}
else
{ // If there is nothing to callback
// ...then don't destroy this. Just let it stay still.
state = eFSState.idle;
}
}
else
{
// 0<=u<1, which means that this is active and moving
state = eFSState.active;
txt.enabled = true; // Show the score once more
}
// Use Bézier curve to move this to the right point
Vector2 pos = Utils.Bezier(uC, bezierPts);
// RectTransform anchors can be used to position UI objects relative
// to total size of the screen
rectTrans.anchorMin = rectTrans.anchorMax = pos;
if (fontSizes != null && fontSizes.Count > 0)
{
// If fontSizes has values in it
// ...then adjust the fontSize of this GUIText
int size = Mathf.RoundToInt(Utils.Bezier(uC, fontSizes));
GetComponent <Text>().fontSize = size;
}
}
}
public float GetValue(float sparam, float time)
{
//1 item, 1 value
if (Items.Count == 1)
{
return(Items [0].GetValue(time));
}
//Find 2 keyframes to interpolate between
AlchemyFloats f1 = null, f2 = null;
for (int i = 0; i < Items.Count - 1; i++)
{
if (sparam >= Items [i].SParam && sparam <= Items [i + 1].SParam)
{
f1 = Items [i];
f2 = Items [i + 1];
break;
}
}
//We're at the end
if (f1 == null)
{
return(Items [Items.Count - 1].GetValue(time));
}
//Interpolate between SParams
var v1 = f1.GetValue(time);
var v2 = f2.GetValue(time);
return(Easing.Ease(Type, sparam, f1.SParam, f2.SParam, v1, v2));
}