public static float evaluateProbabilityCurve(AnimationCurve curve, int sliceCount)
{
/*
allows you to use animationCurves as probability curves.
uses domain 0-1
any range
slices the domain into sliceCount pieces. the odds of returning the x value from a slice
is linearly proportional to the y value on the curve
*/
float total = 0;
float stepSize = 1 / (float)sliceCount;
for (float x=0; x<=1; x+=stepSize) {
total += curve.Evaluate (x);
}
float rand = ((float)Random.Range (0, total * 1000)) / 1000;
for (float x=0; x<=1; x+=stepSize) {
float y = curve.Evaluate (x);
if (y > 0)
rand -= y;
if (rand < 0)
return x;
}
Debug.Log ("warning: evaluateProbabilityCurve never evaluated. returning 1");
return 1f;
}
IEnumerator StoneMove(AnimationCurve curve, float delay = 0 )
{
if (ismoving)
yield break;
ismoving = true;
float timer = 0;
Vector3 stoneOriPosition = stone.transform.position;
Vector3 shadowOriPosition = shadow.transform.position;
while(true)
{
if (timer > delay)
{
stone.transform.position = stoneOriPosition + new Vector3(0,curve.Evaluate((timer-delay)/(glowTime + glowDuration)),0);
shadow.transform.position = shadowOriPosition - new Vector3(0,curve.Evaluate((timer-delay)/(glowTime + glowDuration)),0);
}
if (timer > glowTime + glowDuration + delay)
break;
timer += Time.deltaTime;
yield return null;
}
ismoving = false;
yield break;
}
/*! \cond PRIVATE */
/*! @name Internal Public
* Don't use them unless you know what you're doing!
*/
//@{
void getEvaluatedValues(float percent, ref float radius, ref float zz)
{
switch (RadiusModifier)
{
case ModifierMode.Absolute:
radius = RadiusModifierCurve.Evaluate(percent);
break;
case ModifierMode.Relative:
radius = Radius * RadiusModifierCurve.Evaluate(percent);
break;
default:
radius = Radius;
break;
}
switch (ZModifier)
{
case ModifierMode.Absolute:
zz = ZModifierCurve.Evaluate(percent);
break;
case ModifierMode.Relative:
zz = Z * ZModifierCurve.Evaluate(percent);
break;
default:
zz = Z;
break;
}
}
Vector2[] GetSamplePoints(AnimationCurve curve, Vector2 offset) {
if (curve.length == 0) {
return new Vector2[] { offset, offset };
}
else {
var ret = new List<Vector2>();
float maxTime = GetMaxTime(curve);
for (var t = 0f; t < maxTime; t += sampleInterval) {
ret.Add(new Vector2(t, curve.Evaluate(t)) + offset);
}
ret.Add(new Vector2(maxTime, curve.Evaluate(maxTime)) + offset);
return ret.ToArray();
}
}
public static MeshData GenerateTerrainMesh(float[,] heightMap, float heightMultiplier, AnimationCurve _heightCurve, int levelOfDetail) {
AnimationCurve heightCurve = new AnimationCurve (_heightCurve.keys);
int width = heightMap.GetLength (0);
int height = heightMap.GetLength (1);
float topLeftX = (width - 1) / -2f;
float topLeftZ = (height - 1) / 2f;
int meshSimplificationIncrement = (levelOfDetail == 0)?1:levelOfDetail * 2;
int verticesPerLine = (width - 1) / meshSimplificationIncrement + 1;
MeshData meshData = new MeshData (verticesPerLine, verticesPerLine);
int vertexIndex = 0;
for (int y = 0; y < height; y += meshSimplificationIncrement) {
for (int x = 0; x < width; x += meshSimplificationIncrement) {
meshData.vertices [vertexIndex] = new Vector3 (topLeftX + x, heightCurve.Evaluate (heightMap [x, y]) * heightMultiplier, topLeftZ - y);
meshData.uvs [vertexIndex] = new Vector2 (x / (float)width, y / (float)height);
if (x < width - 1 && y < height - 1) {
meshData.AddTriangle (vertexIndex, vertexIndex + verticesPerLine + 1, vertexIndex + verticesPerLine);
meshData.AddTriangle (vertexIndex + verticesPerLine + 1, vertexIndex, vertexIndex + 1);
}
vertexIndex++;
}
}
return meshData;
}
void Start()
{
_texture = new Texture2D(Width, Height, TextureFormat.ARGB32, false);
_texture.Apply(false, false);
if (_movieCapture)
{
_movieCapture.SetSourceTexture(_texture);
}
_pixels = new Color32[Width*Height];
_palette = new Color32[PaletteSize];
Keyframe[] keysR = { new Keyframe(0f, 0f), new Keyframe(0.25f, 1f), new Keyframe(1f, 0f) };
Keyframe[] keysG = { new Keyframe(0f, 1f), new Keyframe(0.5f, 0f), new Keyframe(1f, 1f) };
Keyframe[] keysB = { new Keyframe(0f, 1f), new Keyframe(0.75f, 0f), new Keyframe(1f, 0f) };
AnimationCurve curveR = new AnimationCurve(keysR);
AnimationCurve curveG = new AnimationCurve(keysG);
AnimationCurve curveB = new AnimationCurve(keysB);
for (int i = 0; i < PaletteSize; i++)
{
float r = curveR.Evaluate((float)i / (float)PaletteSize);
float g = curveG.Evaluate((float)i / (float)PaletteSize);
float b = curveB.Evaluate((float)i / (float)PaletteSize);
_palette[i] = new Color32((byte)(r * 255.0f), (byte)(g * 255.0f), (byte)(b * 255.0f), (byte)(b * 255.0f));
}
}
public static MeshData GenerateTerrainMesh(float[,] heightMap, float heightMultiplier, AnimationCurve _heightCurve, int levelOfDetail) {
AnimationCurve heightCurve = new AnimationCurve (_heightCurve.keys);
int meshSimplificationIncrement = (levelOfDetail == 0)?1:levelOfDetail * 2;
int borderedSize = heightMap.GetLength (0);
int meshSize = borderedSize - 2*meshSimplificationIncrement;
int meshSizeUnsimplified = borderedSize - 2;
float topLeftX = (meshSizeUnsimplified - 1) / -2f;
float topLeftZ = (meshSizeUnsimplified - 1) / 2f;
int verticesPerLine = (meshSize - 1) / meshSimplificationIncrement + 1;
MeshData meshData = new MeshData (verticesPerLine);
int[,] vertexIndicesMap = new int[borderedSize,borderedSize];
int meshVertexIndex = 0;
int borderVertexIndex = -1;
for (int y = 0; y < borderedSize; y += meshSimplificationIncrement) {
for (int x = 0; x < borderedSize; x += meshSimplificationIncrement) {
bool isBorderVertex = y == 0 || y == borderedSize - 1 || x == 0 || x == borderedSize - 1;
if (isBorderVertex) {
vertexIndicesMap [x, y] = borderVertexIndex;
borderVertexIndex--;
} else {
vertexIndicesMap [x, y] = meshVertexIndex;
meshVertexIndex++;
}
}
}
for (int y = 0; y < borderedSize; y += meshSimplificationIncrement) {
for (int x = 0; x < borderedSize; x += meshSimplificationIncrement) {
int vertexIndex = vertexIndicesMap [x, y];
Vector2 percent = new Vector2 ((x-meshSimplificationIncrement) / (float)meshSize, (y-meshSimplificationIncrement) / (float)meshSize);
float height = heightCurve.Evaluate (heightMap [x, y]) * heightMultiplier;
Vector3 vertexPosition = new Vector3 (topLeftX + percent.x * meshSizeUnsimplified, height, topLeftZ - percent.y * meshSizeUnsimplified);
meshData.AddVertex (vertexPosition, percent, vertexIndex);
if (x < borderedSize - 1 && y < borderedSize - 1) {
int a = vertexIndicesMap [x, y];
int b = vertexIndicesMap [x + meshSimplificationIncrement, y];
int c = vertexIndicesMap [x, y + meshSimplificationIncrement];
int d = vertexIndicesMap [x + meshSimplificationIncrement, y + meshSimplificationIncrement];
meshData.AddTriangle (a,d,c);
meshData.AddTriangle (d,a,b);
}
vertexIndex++;
}
}
return meshData;
}
public static IEnumerator CurveDissolve(Material mat, AnimationCurve dissolveCurve, float time, float curveStartPercentage, float speed)
{
float elapsedTime = curveStartPercentage;
while (elapsedTime <= 1f && elapsedTime >= 0f) {
if (mat.HasProperty(dissolveAmountID)) {
mat.SetFloat(dissolveAmountID, Mathf.Clamp01(dissolveCurve.Evaluate(elapsedTime)));
}
elapsedTime += Time.deltaTime/time * speed;
yield return null;
}
if (mat.HasProperty(dissolveAmountID)) {
mat.SetFloat(dissolveAmountID, Mathf.Clamp01(dissolveCurve.Evaluate(Mathf.Clamp01(elapsedTime))));
}
}
/// <summary>
/// Helper function to generate the profile shape to be extruded according to the given curve and parameters.
/// </summary>
/// <param name="profile"></param>
/// <param name="numDivsProfile"></param>
/// <param name="width"></param>
/// <param name="verticalScale"></param>
/// <param name="profileShape"></param>
public static void GenerateProfileShape(AnimationCurve profile, int numDivsProfile, float width, float verticalScale, Shape profileShape, bool collider = false)
{
Vector2[] points = new Vector2[numDivsProfile + 1];
float[] uCoords = new float[numDivsProfile + 1];
Vector2[] normals = new Vector2[numDivsProfile + 1];
for(int i = 0; i < numDivsProfile + 1; ++i)
{
points[i].x = (float)i * (width / numDivsProfile);
points[i].y = -profile.Evaluate(1.0f - Mathf.InverseLerp(0.0f, width, points[i].x)) * verticalScale;
normals[i].x = 0.0f;
normals[i].y = 1.0f;
uCoords[i] = Mathf.InverseLerp(0.0f, width, points[i].x);
points[i].x -= width * 0.5f;
}
int[] lines = new int[points.Length * 2 - 2];
int k = 0;
for (int i = 0; i < points.Length - 1; i++)
{
lines[k] = i;
lines[k + 1] = i + 1;
k += 2;
}
profileShape.points = points;
profileShape.normals = normals;
profileShape.uCoords = uCoords;
profileShape.lines = lines;
}
UnityEngine.Vector3 getScale(float tf)
{
switch (ScaleModifier)
{
case MeshScaleModifier.ControlPoint:
return(Spline.InterpolateScale(tf));
case MeshScaleModifier.UserValue:
return(Spline.InterpolateUserValue(tf, ScaleModifierUserValueSlot));
case MeshScaleModifier.Delegate:
return((OnGetScale != null) ? OnGetScale(this, tf) : UnityEngine.Vector3.one);
case MeshScaleModifier.AnimationCurve:
UnityEngine.Vector3 v = UnityEngine.Vector3.one;
if (ScaleModifierCurve != null)
{
return(v * ScaleModifierCurve.Evaluate(tf));
}
else
{
return(v);
}
default:
return(UnityEngine.Vector3.one);
}
}
static public int Evaluate(IntPtr l)
{
try {
#if DEBUG
var method = System.Reflection.MethodBase.GetCurrentMethod();
string methodName = GetMethodName(method);
#if UNITY_5_5_OR_NEWER
UnityEngine.Profiling.Profiler.BeginSample(methodName);
#else
Profiler.BeginSample(methodName);
#endif
#endif
UnityEngine.AnimationCurve self = (UnityEngine.AnimationCurve)checkSelf(l);
System.Single a1;
checkType(l, 2, out a1);
var ret = self.Evaluate(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
#if DEBUG
finally {
#if UNITY_5_5_OR_NEWER
UnityEngine.Profiling.Profiler.EndSample();
#else
Profiler.EndSample();
#endif
}
#endif
}
public float GetValueFromCurveAtPosition(AnimationCurve curve, float xPosition)
{
float xPos = xPosition + seed;
xPos = xPos % curve[curve.length - 1].time;
var result = curve.Evaluate(xPos);
result += Random.Range(-worldJitterAmount, worldJitterAmount);
result = Mathf.Clamp01(result);
return result;
}
private IEnumerator DoAnimate(AnimationCurve curve)
{
var image = GetComponentInChildren<Image>();
var duration = curve[curve.length - 1].time;
for (var t = 0f; t <= duration; t += Mathf.Max(0.001f, Time.deltaTime)) {
image.color = image.color.WithA(curve.Evaluate(t));
yield return null;
}
}
private IEnumerator DoAnimate(AnimationCurve curve)
{
var renderer = GetComponent<SpriteRenderer>();
var duration = curve[curve.length - 1].time;
for (var t = 0f; t <= duration; t += Mathf.Max(0.001f, Time.deltaTime)) {
renderer.color = renderer.color.WithA(curve.Evaluate(t));
yield return null;
}
}
public static PositionRotation Interpolate(PositionRotation start, PositionRotation end, float progress, AnimationCurve curve)
{
var diff = (end.Position - start.Position);
var curveProgress = curve.Evaluate(progress);
var pos = new Vector3(
start.Position.x + diff.x * curveProgress,
start.Position.y + diff.y * curveProgress,
start.Position.z + diff.z * curveProgress
);
var rot = Quaternion.RotateTowards(start.Rotation, end.Rotation, Quaternion.Angle(start.Rotation, end.Rotation) * curveProgress);
return new PositionRotation(pos, rot);
}
IEnumerator _Coro_FlyProcess(AnimationCurve scaleCurve, float useTime, Vector3 flyLocalDirect)
{
float curTime = 0F;
while (curTime < useTime)
{
transform.localPosition += flyLocalDirect * FlySpeed * Time.deltaTime;
curTime += Time.deltaTime;
float scale = scaleCurve.Evaluate(curTime / useTime);
transform.localScale = new Vector3(scale, scale, 1F);
yield return 0;
}
}
IEnumerator Move(Vector3 pos1, Vector3 pos2, AnimationCurve ac, float time) {
float timer = 0.0f;
pos2 += Random.insideUnitSphere * scatter;
while (timer <= time) {
transform.position = Vector3.Lerp (pos1, pos2, ac.Evaluate(timer/time));
timer += Time.deltaTime;
yield return null;
}
}
public static Color[] ConvertAlphaTexture(Color[] srcColors, bool bEnableAlphaChannel, AnimationCurve curveAlphaWeight, float redWeight, float greenWeight, float blueWeight)
{
for (int c = 0; c < srcColors.Length; c++)
{
if (bEnableAlphaChannel)
{
if (curveAlphaWeight != null)
srcColors[c].a = curveAlphaWeight.Evaluate(srcColors[c].grayscale);
else srcColors[c].a = srcColors[c].grayscale;
} else srcColors[c].a = 1;
}
return srcColors;
}
/// <summary>
/// uses an AnimationCurve for easing. the curve should have a start time of 0. The end time can be anything since
/// it will be scaled but it is usually easiest to just use the 0 - 1 time range.
/// </summary>
/// <returns>The curve ease.</returns>
/// <param name="curve">Curve.</param>
public static Func<float,float,float> AnimationCurveEase( AnimationCurve curve )
{
// we need the curves totaly duration so we can scale it to the actual tweens duration
var curveDuration = curve.keys[curve.length - 1].time;
Func<float,float,float> func = ( t, d ) =>
{
var timeScaler = curveDuration / d;
return curve.Evaluate( timeScaler * t );
};
return func;
}
static public int Evaluate(IntPtr l)
{
try {
UnityEngine.AnimationCurve self = (UnityEngine.AnimationCurve)checkSelf(l);
System.Single a1;
checkType(l, 2, out a1);
var ret = self.Evaluate(a1);
pushValue(l, ret);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
private void UpdateParameter (string fieldName, float baseValue, AnimationCurve curve)
{
var start = curve.keys [0].time;
var end = curve.keys [curve.length - 1].time;
//var step = (end - start) / (springBones.Length - 1);
var prop = springBones [0].GetType ().GetField (fieldName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
for (int i = 0; i < springBones.Length; i++) {
//Kobayashi
if (!springBones [i].isUseEachBoneForceSettings) {
var scale = curve.Evaluate (start + (end - start) * i / (springBones.Length - 1));
prop.SetValue (springBones [i], baseValue * scale);
}
}
}
static int Evaluate(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 2);
UnityEngine.AnimationCurve obj = (UnityEngine.AnimationCurve)ToLua.CheckObject(L, 1, typeof(UnityEngine.AnimationCurve));
float arg0 = (float)LuaDLL.luaL_checknumber(L, 2);
float o = obj.Evaluate(arg0);
LuaDLL.lua_pushnumber(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
public Vector3 GetValueByTimeRatio(float ratio)
{
switch (type)
{
case FlexibleEditType.Uniform:
return(uniformValue);
case FlexibleEditType.RangeTween:
return(new Vector3(rangeX.Evaluate(ratio), rangeY.Evaluate(ratio), rangeZ.Evaluate(ratio)));
case FlexibleEditType.RangeRandom:
return(new Vector3(rangeX.random, rangeY.random, rangeZ.random));
case FlexibleEditType.Curve:
return(new Vector3(curveX.Evaluate(ratio), curveY.Evaluate(ratio), curveZ.Evaluate(ratio)));
}
return(uniformValue);
}
/// <summary>
/// 高さマップを生成する
/// </summary>
/// <param name="gen">生成したリアプノフ</param>
/// <param name="curve">色曲線</param>
/// <returns>高さマップ</returns>
public static Texture2D CreateHeightMap(LyapunovGenerator gen, AnimationCurve curve)
{
Texture2D tex = new Texture2D((int)gen.XLength, (int)gen.YLength);
float diff = 1f / (gen.MaxValue - gen.MinValue);
Color[] color = new Color[gen.XLength * gen.YLength];
for (int i = 0; i < (int)gen.XLength; i++)
{
for (int j = 0; j < (int)gen.YLength; j++)
{
float val = curve.Evaluate(gen.Result[i, j] * diff);
color[i * gen.XLength + j] = new Color(val, val, val, 1);
}
}
tex.SetPixels(color);
tex.Apply();
return tex;
}
public override void Spawn()
{
base.Spawn();
_renderer.sprite = Sprites[Random.Range(0, Sprites.Length)];
RecalculateSizeBySprite();
_collider.size = Size;
HP = Size.magnitude;
_currentMovementPattern = XMovements[Random.Range(0, XMovements.Length)];
_eval = Random.Range(0, _currentMovementPattern.keys[_currentMovementPattern.length-1].time);
transform.position = new Vector3(_currentMovementPattern.Evaluate(_eval) * CameraController.Bounds.x * 0.66f, transform.position.y, transform.position.z);
nextShot = Time.time + FireRate * 2;
_targetHeight = Random.Range(NormalHeight.x, NormalHeight.y) * CameraController.Bounds.y;
}
private IEnumerator FadeToGoal(float goal, float seconds = 0.25f, AnimationCurve filter = null)
{
float startValue = m_audioLoop.volume;
float diff = goal - startValue;
float startTime = Time.time;
float percent = 0.0f; // What percentage of the way through the fade are we.
while(percent < 1.0f) {
percent = Mathf.Clamp01((Time.time - startTime) / seconds);
float filtered = percent;
if ( filter != null ) { filtered = filter.Evaluate(filtered); }
float newVolume = startValue + (filtered * diff);
m_audioLoop.volume = newVolume;
yield return 0;
}
yield break;
}
IEnumerator _Shake(AnimationCurve curve)
{
Vector3 startPos = transform.position;
float duration = curve.lastTime();
yield return StartCoroutine(pTween.RealtimeTo(duration, 0f, duration, t =>
{
float magnitude = (curve.Evaluate(t) / 360f) * Camera.main.orthographicSize;
Vector3 randPos = new Vector3(Random.Range(-magnitude, magnitude), 0, Random.Range(-magnitude, magnitude));
transform.position = startPos + randPos;
t += shakeStayTime / Time.timeScale;
}));
transform.position = startPos;
}
public void TestStepAnimationCurveNode(float time)
{
var animCurve = new UnityEngine.AnimationCurve();
animCurve.AddKey(new UnityEngine.Keyframe(0, 0, Mathf.Infinity, Mathf.Infinity));
animCurve.AddKey(new UnityEngine.Keyframe(0.5f, 1, Mathf.Infinity, Mathf.Infinity));
animCurve.AddKey(new UnityEngine.Keyframe(1, 1, Mathf.Infinity, Mathf.Infinity));
var expected = animCurve.Evaluate(time);
var dotsCurve = animCurve.ToDotsAnimationCurve();
var curveNode = CreateNode <EvaluateCurveNode>();
Set.SendMessage(curveNode, EvaluateCurveNode.SimulationPorts.AnimationCurve, dotsCurve);
Set.SetData(curveNode, EvaluateCurveNode.KernelPorts.Time, time);
var output = CreateGraphValue(curveNode, EvaluateCurveNode.KernelPorts.Output);
Set.Update(default);
private static float[] createAudioWave( AnimationCurve volume, AnimationCurve frequency, LeanAudioOptions options ){
float time = volume[ volume.length - 1 ].time;
List<float> list = new List<float>();
generatedWaveDistances = new List<float>();
// float[] vibratoValues = new float[ vibrato.Length ];
float passed = 0f;
for(int i = 0; i < PROCESSING_ITERATIONS_MAX; i++){
float f = frequency.Evaluate(passed);
if(f<MIN_FREQEUNCY_PERIOD)
f = MIN_FREQEUNCY_PERIOD;
float height = volume.Evaluate(passed + 0.5f*f);
if(options.vibrato!=null){
for(int j=0; j<options.vibrato.Length; j++){
float peakMulti = Mathf.Abs( Mathf.Sin( 1.5708f + passed * (1f/options.vibrato[j][0]) * Mathf.PI ) );
float diff = (1f-options.vibrato[j][1]);
peakMulti = options.vibrato[j][1] + diff*peakMulti;
height *= peakMulti;
}
}
// Debug.Log("i:"+i+" f:"+f+" passed:"+passed+" height:"+height+" time:"+time);
if(passed + 0.5f*f>=time)
break;
generatedWaveDistances.Add( f );
passed += f;
list.Add( passed );
list.Add( i%2==0 ? -height : height );
if(i>=PROCESSING_ITERATIONS_MAX-1){
Debug.LogError("LeanAudio has reached it's processing cap. To avoid this error increase the number of iterations ex: LeanAudio.PROCESSING_ITERATIONS_MAX = "+(PROCESSING_ITERATIONS_MAX*2));
}
}
float[] wave = new float[ list.Count ];
for(int i = 0; i < wave.Length; i++){
wave[i] = list[i];
}
return wave;
}
public static MeshData GenerateTerrainMesh(float[,] heightMap, float heightMultiplier, AnimationCurve _heightCurve, int levelOfDetail)
{
AnimationCurve heightCurve = new AnimationCurve(_heightCurve.keys);
int width = heightMap.GetLength(0);
int height = heightMap.GetLength(1);
float topLeftX = (width - 1) / -2f;
float topLeftZ = (height - 1) / 2f;
int meshSimplificationIncrement = levelOfDetail==0 ? 1 : levelOfDetail * 2; //Pour n'afficher qu'un certain nombre de vertices
int verticesPerLine = (width - 1) / meshSimplificationIncrement + 1;
MeshData meshData = new MeshData(verticesPerLine, verticesPerLine);
int vertexIndex = 0;
for(int y=0;y<height;y+= meshSimplificationIncrement)
{
for(int x=0;x<width;x+= meshSimplificationIncrement)
{
meshData.vertices[vertexIndex] = new Vector3(topLeftX + x, heightCurve.Evaluate(heightMap[x, y]) * heightMultiplier - heightMultiplier*0.01f, topLeftZ - y);
meshData.uvs[vertexIndex] = new Vector2(x / (float)width, y/(float)height);
if(x<width-1 && y < height-1)
{
//On ajoute 2 triangles de façon a créer une face carrée
// /!\ Sens Indirect
meshData.AddTriangle(vertexIndex, vertexIndex + verticesPerLine + 1, vertexIndex + verticesPerLine);
meshData.AddTriangle(vertexIndex + verticesPerLine + 1, vertexIndex, vertexIndex + 1);
}
vertexIndex++;
}
}
return meshData;
}
public static AudioClip generateAudioFromCurve( AnimationCurve curve, int frequencyRate = 44100 )
{
float curveTime = curve[ curve.length - 1 ].time;
float time = curveTime;
float[] audioArr = new float[ (int)(frequencyRate*time) ];
// Debug.Log("curveTime:"+curveTime+" AudioSettings.outputSampleRate:"+AudioSettings.outputSampleRate);
for(int i = 0; i < audioArr.Length; i++){
float pt = (float)i / (float)frequencyRate;
audioArr[i] = curve.Evaluate( pt );
// Debug.Log("pt:"+pt+" i:"+i+" val:"+audioArr[i]+" len:"+audioArr.Length);
}
int lengthSamples = audioArr.Length;//(int)( (float)frequencyRate * curveTime );
#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7
bool is3dSound = false;
AudioClip audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, frequencyRate, is3dSound, false);
#else
AudioClip audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, frequencyRate, false);
#endif
audioClip.SetData(audioArr, 0);
return audioClip;
}
/**
* <summary>Interpolates a float over time, according to various interpolation methods.</summary>
* <param name = "startT">The starting time</param>
* <param name = "deltaT">The time difference</param>
* <param name = "moveMethod">The method of interpolation (Linear, Smooth, Curved, EaseIn, EaseOut, Curved)</param>
* <param name = "timeCurve">The AnimationCurve to interpolate against, if the moveMethod = MoveMethod.Curved</param>
* <returns>The interpolated float</returns>
*/
public static float Interpolate(float startT, float deltaT, MoveMethod moveMethod, AnimationCurve timeCurve = null)
{
if (moveMethod == MoveMethod.Curved)
{
moveMethod = MoveMethod.Smooth;
}
else if (moveMethod == MoveMethod.Smooth)
{
return -0.5f * (Mathf.Cos (Mathf.PI * (Time.time - startT) / deltaT) - 1f);
}
else if (moveMethod == MoveMethod.EaseIn)
{
return 1f - Mathf.Cos ((Time.time - startT) / deltaT * (Mathf.PI / 2));
}
else if (moveMethod == MoveMethod.EaseOut)
{
return Mathf.Sin ((Time.time - startT) / deltaT * (Mathf.PI / 2));
}
else if (moveMethod == MoveMethod.CustomCurve)
{
if (timeCurve == null || timeCurve.length == 0)
{
return 1f;
}
float startTime = timeCurve [0].time;
float endTime = timeCurve [timeCurve.length - 1].time;
return timeCurve.Evaluate ((endTime - startTime) * (Time.time - startT) / deltaT + startTime);
}
return ((Time.time - startT) / deltaT);
}
public static float CalcMassFlow(float time, AnimationCurve massFlow)
{
float f;
f = massFlow.Evaluate(time);
//if (!HighLogic.LoadedSceneIsEditor)
//{
// if (thrustVariation > .0001f)
// f = f * (1 + CalcMassFlux());
//}
if (f > 0)
return f;
else
return 0;
}
public static float getCurveValue(AnimationCurve _curve, float _t)
{
return _curve.Evaluate(_t);
}
public float Evaluate(float step)
{
return(animationCurve.Evaluate(step));
}
public static float ScaleInputBySymmetricCurve(float input, AnimationCurve curve)
{
return curve.Evaluate(Mathf.Abs(input)) * Mathf.Sign(input);
}
public static float ScaleInputByAsymmetricCurve(float input, AnimationCurve curve)
{
return curve.Evaluate(input);
}
// public static AnimationCurve CreateCurveByPairedData( float[] pairedDatas)
// {
// D.Assert( pairedDatas.Length % 2 == 0, "check pairedData Count");
//
// }
public static AnimationCurve SpeedCurve( AnimationCurve curve, float interval = 0.1f){
D.Assert(interval > 0);
float sTime = curve.keys[0].time;
float eTime = curve.keys[curve.keys.Length-1].time;
List<Keyframe> ks = new List<Keyframe>();
float time = sTime;
float nextTime = sTime + interval;
while ( nextTime < eTime){
float sp = (curve.Evaluate(time + interval) - curve.Evaluate(time))/interval;
ks.Add(new Keyframe(time, sp));
time = nextTime;
nextTime += interval;
}
D.Assert(eTime > time);
ks.Add( new Keyframe( eTime, (curve.Evaluate( eTime) - curve.Evaluate(time)) /(eTime - time) ) );
return ChpAnimation.CreateCurve( ks.ToArray() );
}
