Untiy中的数据平滑处理

本文章由cartzhang编写，转载请注明出处。 所有权利保留。

文章链接：http://blog.csdn.net/cartzhang/article/details/50680237

作者：cartzhang

数据平滑处理

由于需要处理硬件的传给数据，硬件是其他商家的。

坑爹的是发送频率太低了，20HZ左右，也是服气了。好处有么，肯定是便宜。

这个用在VR游戏上，不做评论了。

既然这样，生活还得继续！！！

怎么办？

插值

第一考虑的就是插值。

插值，内插和外推插值。插值算法，有多种，5点，7点，二次插值等，不一一列举。

游戏的帧率在DK2上75fps,这帧率插值，需要至少有2秒数据，再加上硬件数据的抖动，个人觉得这不算是个好的方案。

缓动函数

在ITween中有个缓动曲线函数。

这个不错啊！我们来细说下。

1.先看看各种函数都长啥样？

截图：

2.网址介绍

相关网址啊：

http://easings.net/zh-cn#

说明网址上的各个图都是可以点开，动态的哦。

http://robertpenner.com/easing/easing_demo.html

这个也是可以看看每个曲线的样子。真是方便啊！！

微软msdn上带有代码和图例的

https://msdn.microsoft.com/zh-cn/library/ee308751.aspx

3.在看看所有曲线种类。

可以在ITween中找到EaseType.

/// <summary>
/// The type of easing to use based on Robert Penner's open source easing equations (http://www.robertpenner.com/easing_terms_of_use.html).
/// </summary>
public enum EaseType{
easeInQuad,
easeOutQuad,
easeInOutQuad,
easeInCubic,
easeOutCubic,
easeInOutCubic,
easeInQuart,
easeOutQuart,
easeInOutQuart,
easeInQuint,
easeOutQuint,
easeInOutQuint,
easeInSine,
easeOutSine,
easeInOutSine,
easeInExpo,
easeOutExpo,
easeInOutExpo,
easeInCirc,
easeOutCirc,
easeInOutCirc,
linear,
spring,
/* GFX47 MOD START */
//bounce,
easeInBounce,
easeOutBounce,
easeInOutBounce,
/* GFX47 MOD END */
easeInBack,
easeOutBack,
easeInOutBack,
/* GFX47 MOD START */
//elastic,
easeInElastic,
easeOutElastic,
easeInOutElastic,
/* GFX47 MOD END */
punch
}

根据需要各区所需啊！！不一定要全部都带上。

4. 函数代码：

ITween中这个代码比较长，代码中更多的是算法。

代码在ITween.cs中，就不一一贴上来。

缓动曲线代码

我需要的只有这些曲线，其他的不需要，就摘了出来，写成了静态函数，这样方便在需要时候直接调用。

/**************************************************************************
Copyright:@cartzhang
Author: cartzhang
Date:
Description:
**************************************************************************/
using UnityEngine;
using System.Collections;

public enum EaseType:int
{
easeInQuad,
//easeOutQuad,
easeInOutQuad,
easeInCubic,
//easeOutCubic,
easeInOutCubic,
easeInQuart,
//easeOutQuart,
easeInOutQuart,
easeInQuint,
//easeOutQuint,
easeInOutQuint,
//easeInSine,
//easeOutSine,
//easeInOutSine,
easeInExpo,
//easeOutExpo,
easeInOutExpo,
//easeInCirc,
//easeOutCirc,
easeInOutCirc,
//linear,
//spring,
///* GFX47 MOD START */
////bounce,
//easeInBounce,
//easeOutBounce,
//easeInOutBounce,
///* GFX47 MOD END */
//easeInBack,
//easeOutBack,
//easeInOutBack,
///* GFX47 MOD START */
////elastic,
//easeInElastic,
//easeOutElastic,
//easeInOutElastic,
///* GFX47 MOD END */
//punch
}

public class DataAlgorithm
{

#region Easing Curves

public static float linear(float start, float end, float value)
{
return Mathf.Lerp(start, end, value);
}

public static float clerp(float start, float end, float value)
{
float min = 0.0f;
float max = 360.0f;
float half = Mathf.Abs((max - min) / 2.0f);
float retval = 0.0f;
float diff = 0.0f;
if ((end - start) < -half)
{
diff = ((max - start) + end) * value;
retval = start + diff;
}
else if ((end - start) > half)
{
diff = -((max - end) + start) * value;
retval = start + diff;
}
else retval = start + (end - start) * value;
return retval;
}

public static float spring(float start, float end, float value)
{
value = Mathf.Clamp01(value);
value = (Mathf.Sin(value * Mathf.PI * (0.2f + 2.5f * value * value * value)) * Mathf.Pow(1f - value, 2.2f) + value) * (1f + (1.2f * (1f - value)));
return start + (end - start) * value;
}

public static float easeInQuad(float start, float end, float value)
{
end -= start;
return end * value * value + start;
}

public static float easeOutQuad(float start, float end, float value)
{
end -= start;
return -end * value * (value - 2) + start;
}

public static float easeInOutQuad(float start, float end, float value)
{
value /= .5f;
end -= start;
if (value < 1) return end / 2 * value * value + start;
value--;
return -end / 2 * (value * (value - 2) - 1) + start;
}

public static float easeInCubic(float start, float end, float value)
{
end -= start;
return end * value * value * value + start;
}

public static float easeOutCubic(float start, float end, float value)
{
value--;
end -= start;
return end * (value * value * value + 1) + start;
}

public static float easeInOutCubic(float start, float end, float value)
{
value /= .5f;
end -= start;
if (value < 1) return end / 2 * value * value * value + start;
value -= 2;
return end / 2 * (value * value * value + 2) + start;
}

public static float easeInQuart(float start, float end, float value)
{
end -= start;
return end * value * value * value * value + start;
}

public static float easeOutQuart(float start, float end, float value)
{
value--;
end -= start;
return -end * (value * value * value * value - 1) + start;
}

public static float easeInOutQuart(float start, float end, float value)
{
value /= .5f;
end -= start;
if (value < 1) return end / 2 * value * value * value * value + start;
value -= 2;
return -end / 2 * (value * value * value * value - 2) + start;
}

public static float easeInQuint(float start, float end, float value)
{
end -= start;
return end * value * value * value * value * value + start;
}

public static float easeOutQuint(float start, float end, float value)
{
value--;
end -= start;
return end * (value * value * value * value * value + 1) + start;
}

public static float easeInOutQuint(float start, float end, float value)
{
value /= .5f;
end -= start;
if (value < 1) return end / 2 * value * value * value * value * value + start;
value -= 2;
return end / 2 * (value * value * value * value * value + 2) + start;
}

public static float easeInSine(float start, float end, float value)
{
end -= start;
return -end * Mathf.Cos(value / 1 * (Mathf.PI / 2)) + end + start;
}

public static float easeOutSine(float start, float end, float value)
{
end -= start;
return end * Mathf.Sin(value / 1 * (Mathf.PI / 2)) + start;
}

public static float easeInOutSine(float start, float end, float value)
{
end -= start;
return -end / 2 * (Mathf.Cos(Mathf.PI * value / 1) - 1) + start;
}

public static float easeInExpo(float start, float end, float value)
{
end -= start;
return end * Mathf.Pow(2, 10 * (value / 1 - 1)) + start;
}

public static float easeOutExpo(float start, float end, float value)
{
end -= start;
return end * (-Mathf.Pow(2, -10 * value / 1) + 1) + start;
}

public static float easeInOutExpo(float start, float end, float value)
{
value /= .5f;
end -= start;
if (value < 1) return end / 2 * Mathf.Pow(2, 10 * (value - 1)) + start;
value--;
return end / 2 * (-Mathf.Pow(2, -10 * value) + 2) + start;
}

public static float easeInCirc(float start, float end, float value)
{
end -= start;
return -end * (Mathf.Sqrt(1 - value * value) - 1) + start;
}

public static float easeOutCirc(float start, float end, float value)
{
value--;
end -= start;
return end * Mathf.Sqrt(1 - value * value) + start;
}

public static float easeInOutCirc(float start, float end, float value)
{
value /= .5f;
end -= start;
if (value < 1) return -end / 2 * (Mathf.Sqrt(1 - value * value) - 1) + start;
value -= 2;
return end / 2 * (Mathf.Sqrt(1 - value * value) + 1) + start;
}

/* GFX47 MOD START */
public static float easeInBounce(float start, float end, float value)
{
end -= start;
float d = 1f;
return end - easeOutBounce(0, end, d - value) + start;
}
/* GFX47 MOD END */

/* GFX47 MOD START */
//public static float bounce(float start, float end, float value){
public static float easeOutBounce(float start, float end, float value)
{
value /= 1f;
end -= start;
if (value < (1 / 2.75f))
{
return end * (7.5625f * value * value) + start;
}
else if (value < (2 / 2.75f))
{
value -= (1.5f / 2.75f);
return end * (7.5625f * (value) * value + .75f) + start;
}
else if (value < (2.5 / 2.75))
{
value -= (2.25f / 2.75f);
return end * (7.5625f * (value) * value + .9375f) + start;
}
else
{
value -= (2.625f / 2.75f);
return end * (7.5625f * (value) * value + .984375f) + start;
}
}
/* GFX47 MOD END */

/* GFX47 MOD START */
public static float easeInOutBounce(float start, float end, float value)
{
end -= start;
float d = 1f;
if (value < d / 2) return easeInBounce(0, end, value * 2) * 0.5f + start;
else return easeOutBounce(0, end, value * 2 - d) * 0.5f + end * 0.5f + start;
}
/* GFX47 MOD END */

public static float easeInBack(float start, float end, float value)
{
end -= start;
value /= 1;
float s = 1.70158f;
return end * (value) * value * ((s + 1) * value - s) + start;
}

public static float easeOutBack(float start, float end, float value)
{
float s = 1.70158f;
end -= start;
value = (value / 1) - 1;
return end * ((value) * value * ((s + 1) * value + s) + 1) + start;
}

public static float easeInOutBack(float start, float end, float value)
{
float s = 1.70158f;
end -= start;
value /= .5f;
if ((value) < 1)
{
s *= (1.525f);
return end / 2 * (value * value * (((s) + 1) * value - s)) + start;
}
value -= 2;
s *= (1.525f);
return end / 2 * ((value) * value * (((s) + 1) * value + s) + 2) + start;
}

public static float punch(float amplitude, float value)
{
float s = 9;
if (value == 0)
{
return 0;
}
if (value == 1)
{
return 0;
}
float period = 1 * 0.3f;
s = period / (2 * Mathf.PI) * Mathf.Asin(0);
return (amplitude * Mathf.Pow(2, -10 * value) * Mathf.Sin((value * 1 - s) * (2 * Mathf.PI) / period));
}

/* GFX47 MOD START */
public static float easeInElastic(float start, float end, float value)
{
end -= start;

float d = 1f;
float p = d * .3f;
float s = 0;
float a = 0;

if (value == 0) return start;

if ((value /= d) == 1) return start + end;

if (a == 0f || a < Mathf.Abs(end))
{
a = end;
s = p / 4;
}
else
{
s = p / (2 * Mathf.PI) * Mathf.Asin(end / a);
}

return -(a * Mathf.Pow(2, 10 * (value -= 1)) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p)) + start;
}
/* GFX47 MOD END */

/* GFX47 MOD START */
//public static float elastic(float start, float end, float value){
public static float easeOutElastic(float start, float end, float value)
{
/* GFX47 MOD END */
//Thank you to rafael.marteleto for fixing this as a port over from Pedro's UnityTween
end -= start;

float d = 1f;
float p = d * .3f;
float s = 0;
float a = 0;

if (value == 0) return start;

if ((value /= d) == 1) return start + end;

if (a == 0f || a < Mathf.Abs(end))
{
a = end;
s = p / 4;
}
else
{
s = p / (2 * Mathf.PI) * Mathf.Asin(end / a);
}

return (a * Mathf.Pow(2, -10 * value) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p) + end + start);
}

/* GFX47 MOD START */
public static float easeInOutElastic(float start, float end, float value)
{
end -= start;

float d = 1f;
float p = d * .3f;
float s = 0;
float a = 0;

if (value == 0) return start;

if ((value /= d / 2) == 2) return start + end;

if (a == 0f || a < Mathf.Abs(end))
{
a = end;
s = p / 4;
}
else
{
s = p / (2 * Mathf.PI) * Mathf.Asin(end / a);
}

if (value < 1) return -0.5f * (a * Mathf.Pow(2, 10 * (value -= 1)) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p)) + start;
return a * Mathf.Pow(2, -10 * (value -= 1)) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p) * 0.5f + end + start;
}
/* GFX47 MOD END */

#endregion

}

总结：

这个使用还是非常方便的。对于数据的处理和抖动，目前来看还是比较有用的。

这么实用有好用 的东西，当然要记录下来，仅供参考。

若有问题，请随时联系！！

非常感谢！！！！