C# Keyframe类代码示例

	public static AnimationCurve CreateCurve( float[] values, float[] times, bool smooth = true)
	{
		D.Assert( values != null && times != null, "Param == null" );
		D.Assert( values.Length == times.Length, "Size not same" );
		if ( values.Length != times.Length ){
			D.Log("values.Length: {0}   times.Length: {1}", values.Length, times.Length);
		}
		
		AnimationCurve result;
		Keyframe[] ks = new Keyframe[values.Length];
		for( int i = 0; i < values.Length; i ++ ) {
			ks[ i ] = new Keyframe( times[ i ], values[ i ] );
		}
		result = new AnimationCurve( ks );
		if ( smooth){
			for( int i = 0; i < result.length; i++ ) {
				result.SmoothTangents( i, 0 );
			}
		}
		return result;
	}

    void Start()
    {
        GameObject.Find("GUI Text").guiText.text = "AnimationClip sample";

        AnimationClip clipA = new AnimationClip();
        AnimationCurve curveA = AnimationCurve.Linear(0f, 3f, 3f, 3f);
        Keyframe keyA = new Keyframe(1.5f, 10f);
        curveA.AddKey(keyA);
        clipA.SetCurve("", typeof(Transform), "localPosition.z", curveA);
        clipA.wrapMode = WrapMode.Loop;
        animation.AddClip(clipA, "anim1");

        AnimationClip clipB = new AnimationClip();
        AnimationCurve curveB = AnimationCurve.Linear(0f, 3f, 3f, 3f);
        Keyframe key1 = new Keyframe(0.75f, 7f);
        curveB.AddKey(key1);
        Keyframe key2 = new Keyframe(1.5f, 3f);
        curveB.AddKey(key2);
        Keyframe key3 = new Keyframe(2.25f,7f);
        curveB.AddKey (key3);
        clipB.SetCurve("", typeof(Transform), "localPosition.z", curveB);
        clipB.wrapMode = WrapMode.Loop;
        animation.AddClip(clipB, "anim2");

        animation.Play ("anim1");
    }

    // Use this for initialization
    void Start()
    {
        GameObject[] ob_cubes;

        ob_cubes = GameObject.FindGameObjectsWithTag("ob_cube");

        foreach (GameObject obj in ob_cubes)
        {
            Vector3 move = obj.transform.position;
            AnimationClip clip = new AnimationClip();
            clip.legacy = true;
            Keyframe[] keysX = new Keyframe[2];
            keysX[0] = new Keyframe(0f, move.x - 5);
            keysX[1] = new Keyframe(1f, move.x + 3);
            AnimationCurve curveX = new AnimationCurve(keysX);
            clip.SetCurve("", typeof(Transform), "localPosition.x", curveX);
            clip.wrapMode = WrapMode.PingPong;
            Keyframe[] keysY = new Keyframe[2];
            keysY[0] = new Keyframe(0f, move.y);
            keysY[1] = new Keyframe(1f, move.y);
            AnimationCurve curveY = new AnimationCurve(keysY);
            clip.SetCurve("", typeof(Transform), "localPosition.y", curveY);
            Keyframe[] keysZ = new Keyframe[2];
            keysZ[0] = new Keyframe(0f, move.z);
            keysZ[1] = new Keyframe(1f, move.z);
            AnimationCurve curveZ = new AnimationCurve(keysZ);
            clip.SetCurve("", typeof(Transform), "localPosition.z", curveZ);
            Animation animation = obj.GetComponent<Animation>();
            animation.AddClip(clip, "clip1");
            animation.Play("clip1");
        }
    }

        public void Test_New2()
        {
            var frame = new Keyframe (1, new Vector3(1,2,3));

            Assert.AreEqual (1, frame.Time);
            Assert.AreEqual (new Vector3(1,2,3), frame.Value);
        }

    /// <summary>
    /// Create drift orbit
    /// </summary>
    public void Drift(Vector3 origin, float speed, out AnimationCurve[] ac)
    {
        Keyframe[][] kf = new Keyframe[2][];
        kf[X] = new Keyframe[driftPoints + 2];
        kf[Y] = new Keyframe[driftPoints + 2];

        kf[X][0] = new Keyframe(0, origin.x, inTangent, outTangent);
        kf[Y][0] = new Keyframe(0, origin.y, inTangent, outTangent);

        for (int i = 1; i <= driftPoints; i++)
        {
            kf[X][i] = new Keyframe(i / speed, origin.x + (driftX * Random.value), inTangent, outTangent);
            kf[Y][i] = new Keyframe(i / speed, origin.y + (driftY * Random.value), inTangent, outTangent);
        }

        kf[X][driftPoints + 1] = new Keyframe((driftPoints + 1) / speed, origin.x, inTangent, outTangent);
        kf[Y][driftPoints + 1] = new Keyframe((driftPoints + 1) / speed, origin.y, inTangent, outTangent);

        // Curves
        ac = new AnimationCurve[2];
        ac[X] = new AnimationCurve(kf[X]);
        ac[Y] = new AnimationCurve(kf[Y]);

        // Smooth curves
        for (int i = 0; i < ac[X].keys.Length; ++i)
        {
            ac[X].SmoothTangents(i, 0);
            ac[Y].SmoothTangents(i, 0);
        }
    }

 public void ApplyPose(Keyframe pose)
 {
     currentPose = pose;
     SetLocalTranslation(pose.GetTranslation());
     poseRot = pose.GetRotation();
     UpdateTransform();
 }

    void CreateAnimationClip()
    {
        CameraShakeTool tool = target as CameraShakeTool;

        List<Keyframe> keyframeList = new List<Keyframe>();

        foreach (Vector2 v in tool.value)
        {
            Keyframe k = new Keyframe(v.x, v.y);
            keyframeList.Add(k);
        }

        AnimationClip clip = new AnimationClip();
        #if UNITY_5
        clip.legacy = true;
        #endif
        clip.wrapMode = WrapMode.Once;

        clip.SetCurve("", typeof(Transform), "localPosition.x", new AnimationCurve(keyframeList.ToArray()));

        string activePath = AssetDatabase.GetAssetPath(Selection.activeObject);
        string directory = Path.GetDirectoryName(activePath);
        string filename = Path.GetFileNameWithoutExtension(activePath);
        string path = directory + "/" + filename + ".anim";
        string clipPath = AssetDatabase.GenerateUniqueAssetPath(path);

        AssetDatabase.CreateAsset(clip, clipPath);
    }

    void Start()
    {
        moves[0] = new Vector3( 0f, 1f,  0f);
        moves[1] = new Vector3(-3f, 1f,  5f);
        moves[2] = new Vector3( 3f, 1f,  5f);
        moves[3] = new Vector3(-3f, 1f, -3f);
        moves[4] = new Vector3( 3f, 1f, -3f);
        for(int i=0;i<5;i++){
            cubes[i] = GameObject.Find ("BoardCube"+i);
            Vector3 move = cubes[i].transform.position;
            AnimationClip clip = new AnimationClip();
            Keyframe[] keysX = new Keyframe[2];
            keysX[0] = new Keyframe(  0f, move.x-3);
            keysX[1] = new Keyframe(i+1f, move.x+3);
            AnimationCurve curveX = new AnimationCurve(keysX);
            clip.SetCurve("", typeof(Transform), "localPosition.x", curveX);
            clip.wrapMode = WrapMode.PingPong;

            Keyframe[] keysY = new Keyframe[2];
            keysY[0] = new Keyframe(  0f, move.y);
            keysY[1] = new Keyframe(i+1f, move.y);
            AnimationCurve curveY = new AnimationCurve(keysY);
            clip.SetCurve("", typeof(Transform), "localPosition.y", curveY);

            Keyframe[] keysZ = new Keyframe[2];
            keysZ[0] = new Keyframe(  0f, move.z);
            keysZ[1] = new Keyframe(i+1f, move.z);
            AnimationCurve curveZ = new AnimationCurve(keysZ);
            clip.SetCurve("", typeof(Transform), "localPosition.z", curveZ);

            cubes[i].animation.AddClip(clip, "clip1");
            cubes[i].animation.Play("clip1");
        }
    }

        public void Test_New1()
        {
            var frame = new Keyframe (1, 2);

            Assert.AreEqual (1, frame.Time);
            Assert.AreEqual (2, frame.Value);
        }

			public static bool CurveIsWrong(Keyframe[] aCurve)
			{
				if (null == aCurve || 1 > aCurve.Length)
					return true;
				else
					return false;
			}

    void SetLoupiotteAproach()
    {
        AnimationClip clip = new AnimationClip();
        Keyframe[] xValues = new Keyframe[5];
        Keyframe[] yValues = new Keyframe[5];
        Keyframe[] zValues = new Keyframe[5];
        Keyframe[] stateValues = new Keyframe[5];
        for (int i = 0; i<5; i++)
        {
            xValues[i] = new Keyframe(i * 3.0f, i < 4 ? Random.Range(-20.0f / (2 * i + 1), 20.0f / (2 * i + 1)) : xReference);
            zValues[i] = new Keyframe(i * 3.0f, i < 4 ? Random.Range(-20.0f / (2 * i + 1), 20.0f / (2 * i + 1)) : zReference);
            stateValues[i] = new Keyframe(i * 3.0f, i < 4 ? 0.0f : 1.0f);
        }

        yValues[0] = new Keyframe(0.0f, 50.0f);
        yValues[1] = new Keyframe(3.0f, 35.0f);
        yValues[2] = new Keyframe(6.0f, 25.0f);
        yValues[3] = new Keyframe(9.0f, 15.0f);
        yValues[4] = new Keyframe(12.0f, yReference);

        AnimationCurve xCurve = new AnimationCurve(xValues);
        AnimationCurve yCurve = new AnimationCurve(yValues);
        AnimationCurve zCurve = new AnimationCurve(zValues);
        AnimationCurve stateCurve = new AnimationCurve(stateValues);
        clip.legacy = true;
        clip.SetCurve("", typeof(Loupiotte), "positionToPlayer.x", xCurve);
        clip.SetCurve("", typeof(Loupiotte), "positionToPlayer.y", yCurve);
        clip.SetCurve("", typeof(Loupiotte), "positionToPlayer.z", zCurve);
        clip.SetCurve("", typeof(Loupiotte), "state", stateCurve);

        anim.AddClip(clip, "Approche");
    }

			public static float CalculateCurvesPoint(Keyframe[] aCurve, long nFrame)
			{
				if (null == aCurve || 1> aCurve.Length)
					throw new Exception("curve is empty");
				Keyframe[] aInterval=FindInterval(aCurve, nFrame);
				if (1 == aInterval.Length)
				{
					if (aCurve[0] == aInterval[0])
						; // в идеале расчитать экстрапол¤цию за границы диапазона (касательна¤ в ту же сторону)
					if (aCurve[aCurve.Length - 1] == aInterval[0])
						; // в идеале расчитать экстрапол¤цию за границы диапазона (касательна¤ в ту же сторону)
					return aInterval[0].nPosition; // но пока просто остаЄмс¤ на этой точке
				}

				float nRetVal = 0;
				switch (aInterval[0].eType)
				{
					case Keyframe.Type.hold:
						// формула y=A при M<=x<N  
						nRetVal = aInterval[0].nPosition;
						break;
					case Keyframe.Type.linear:
						// формула y=kx+h, где y-пиксели, x-фреймы. M, N - точки на х; A, B - точки на y, то люба¤ точка (PX, FR) <=  PX=((B-A)/(N-M))*(FR-M)+A
						nRetVal = ((aInterval[1].nPosition - aInterval[0].nPosition) / (aInterval[1].nFrame - aInterval[0].nFrame)) * (nFrame - aInterval[0].nFrame) + aInterval[0].nPosition;
						break;
					case Keyframe.Type.besier:
						break;
					default:
						break;
				}
				return nRetVal;
			}

 //  
 public AnimationInstance(Animation anim)
 {
   animation_ = anim;
   frameRate_ = anim.FrameRate;
   //  The time of the last frame is less than the duration of the animation,
   //  as the last frame has some duration itself.
   lastFrameTime_ = (anim.NumFrames - 1) / frameRate_;
   invFrameRate_ = 1.0f / frameRate_;
   duration_ = anim.NumFrames * invFrameRate_;
   int max = 0;
   //  calculate max bone index
   //  todo: do in content pipeline
   foreach (KeyValuePair<int, AnimationTrack> kvp in anim.Tracks)
   {
     if (kvp.Key >= max)
       max = kvp.Key + 1;
   }
   //  Allocate animation keyframes (for lerping between times).
   keyframes_ = new Keyframe[max];
   //  Load all the tracks (one track per bone).
   tracks_ = new AnimationTrack[max];
   foreach (int i in anim.Tracks.Keys)
   {
     keyframes_[i] = new Keyframe();
     tracks_[i] = anim.Tracks[i];
   }
 }

	public static AnimationCurve CreateLineraCurve( float[] values, float[] times )
	{
		D.Assert( values != null && times != null, "Param == null" );
		D.Assert( values.Length == times.Length, "Size not same" );
		
		AnimationCurve result;
		Keyframe[] ks = new Keyframe[values.Length];
		for( int i = 0; i < values.Length; i ++ ) {
			float inTgt;
			float outTgt;
			if ( i == 0){
				inTgt = 0;
			}else{
				inTgt = (values[ i ] - values[i-1])/(times[i] - times[i-1]);
			}
			if ( i == values.Length -1){
				outTgt = 0;
			}else{
				outTgt = (values[ i+1 ] - values[i])/(times[i+1] - times[i]);
			}
			
			ks[ i ] = new Keyframe( times[ i ], values[ i ], inTgt, outTgt );
		}
		result = new AnimationCurve( ks );
		return result;
	}

 // UnityEditor.CurveUtility.cs (c) Unity Technologies
 public static TangentMode GetKeyTangentMode(Keyframe keyframe, int leftRight)
 {
     Type t = typeof(UnityEngine.Keyframe);
     FieldInfo field = t.GetField("m_TangentMode", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
     int tangentMode = (int)field.GetValue(keyframe);
     if(leftRight == 0)
         return (TangentMode)((tangentMode & 6) >> 1);
     else
         return (TangentMode)((tangentMode & 24) >> 3);
 }