本文章由cartzhang编写，转载请注明出处。 所有权利保留。
文章链接：[http://blog.csdn.net/cartzhang/article/details/50680237](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://easings.net/zh-cn#)
说明网址上的各个图都是可以点开，动态的哦。
[http://robertpenner.com/easing/easing_demo.html](http://robertpenner.com/easing/easing_demo.html)
这个也是可以看看每个曲线的样子。真是方便啊！！
微软msdn上带有代码和图例的
[https://msdn.microsoft.com/zh-cn/library/ee308751.aspx](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
}
~~~
### 总结：
这个使用还是非常方便的。对于数据的处理和抖动，目前来看还是比较有用的。
这么实用有好用 的东西，当然要记录下来，仅供参考。
若有问题，请随时联系！！
非常感谢！！！！
- 前言
- Unity随机Prefab，自动前往某点处理
- Unity导入FBX自动进行动画切分
- Unity5中的粒子缩放(附测试源码)
- Unity和虚幻的比较
- Unity 实现Log实时输出到屏幕或控制台上&lt;一&gt;
- Unity 实现Log实时输出到屏幕或控制台上&lt;二&gt;
- Unity的Json解析<一>--读取Json文件
- Unity的Json解析<二>–写Json文件
- Unity 的OCulus VR开发遇到的坑---OC版本差异
- Unity中一键创建常用文件夹
- Unity版本与虚拟现实头盔Deepoon大朋版本测试
- Unity 多场景打包
- Untiy中的数据平滑处理
- Unity中SendMessage和Delegate效率比较