コード例 #1
0
ファイル: CreateLegacyAnimation.cs プロジェクト: 2ty/race3d
 static void Criate()
 {
     string dir = "Assets/";
     Object selected = Selection.activeObject;
     if (selected != null) {
         string assetDir = AssetDatabase.GetAssetPath(selected.GetInstanceID());
         if (assetDir.Length > 0 && Directory.Exists(assetDir))
             dir = assetDir + "/";
     }
     AnimationClip	clip	= new AnimationClip ();
     clip.frameRate	= 30.0f;
     clip.legacy		= true;
     string	name	= "New Animation (Legacy)";
     string	extension	= ".anim";
     if (AssetDatabase.LoadAssetAtPath<AnimationClip> (string.Format (dir+name+extension)) != null) {
         int prefix = 1;
         while (AssetDatabase.LoadAssetAtPath<AnimationClip> (string.Format (dir+name+" {0:0}" + extension, prefix)) != null) {
             prefix++;
         }
         name	=  string.Format (name+" {0:0}", prefix);
     }
     AssetDatabase.CreateAsset(clip, dir + name + extension);
     AssetDatabase.SaveAssets();
     EditorUtility.FocusProjectWindow();
     Selection.activeObject = clip;
 }
コード例 #2
0
 public void Cleanup()
 {
     ab.Unload(true);
     originClip = null;
     ab         = null;
     clip       = null;
 }
コード例 #3
0
 static public int constructor(IntPtr l)
 {
     UnityEngine.AnimationClip o;
     o = new UnityEngine.AnimationClip();
     pushObject(l, o);
     return(1);
 }
コード例 #4
0
        public static State GetCurveState(AnimationClip clip, EditorCurveBinding[] selection)
        {
            State state;
            state.allAreNonBaked = true;
            state.allAreBaked = false;
            state.allAreRotations = false;
            foreach (EditorCurveBinding binding in selection)
            {
                switch (GetModeFromCurveData(binding))
                {
                    case Mode.NonBaked:
                        state.allAreNonBaked = false;
                        break;

                    case Mode.Baked:
                        state.allAreBaked = false;
                        break;

                    default:
                        state.allAreRotations = false;
                        break;
                }
            }
            return state;
        }
コード例 #5
0
	/**
	 * The drawing function
	 */
	void OnGUI()
	{
		// Display the field for which animation clip we should inspect
		_AnimClip = EditorGUILayout.ObjectField( _AnimClip, typeof(AnimationClip), false ) as AnimationClip;
		if ( _AnimClip == null )
		{
			EditorGUILayout.HelpBox( "Drag an Animation Clip onto the slot above", MessageType.Info, true );
			return;
		}
		
		// If we've changed animation clips... recache our data
		if ( GUI.changed )
		{
			PopulateCurves();
			GUI.changed = false;
			
			Repaint();
		}
		
		// Draw the path tree for all curves in a scrollable area
		_ScrollPosition = EditorGUILayout.BeginScrollView( _ScrollPosition );
		DrawPathTree( _RootPathNode );
		EditorGUILayout.EndScrollView();
		
		// Save the changes if we're done
		if ( GUILayout.Button("Save Changes") )
		{
			SaveCurveChanges();
			Repaint();
		}
	}
コード例 #6
0
ファイル: MecanimEvent.cs プロジェクト: lbddk/ahzs-client
 /// <summary>
 /// 监测动作状态变迁。
 /// </summary>
 /// <param name="StateChanged">动画状态变化事件。
 /// String: 动画名称。
 /// Boolean: 动画变化状态。true: 动画开始;false: 动画结束。
 /// </param>
 /// <returns>迭代器。</returns>
 public IEnumerator CheckAnimationChange(Action<String, Boolean> StateChanged)
 {
     while (true)
     {
         var state = m_animator.GetCurrentAnimationClipState(0);//获取当前播放动作状态
         if (state.Length != 0)
             if (state[0].weight != 1)//当前动作正在融合
             {
                 if (m_isNotFadeing)//判断已标记为融合,如果不是融合,则表示为刚开始融合,此刻为下一个动作的开始点
                 {
                     var nextState = m_animator.GetNextAnimationClipState(0);
                     if (StateChanged != null && nextState.Length != 0)
                         StateChanged(nextState[0].clip.name, true);//LoggerHelper.Debug(nextState[0].clip.name + " start...");
                     m_currentMark = state[0].clip;//更新当前动作
                     m_isNotFadeing = false;//标记为融合状态
                     yield return new WaitForFixedUpdate();
                 }
             }
             else
             {
                 if (m_currentMark != state[0].clip)//在动作变迁时,state会瞬间变为新动作,weight变为1,所以需判断state是否已改变,此刻为旧动作结束点
                 {
                     if (m_currentMark != null && StateChanged != null)
                         StateChanged(m_currentMark.name, false);//LoggerHelper.Debug(currentMark.name + " end...");
                     m_currentMark = state[0].clip;//更新当前动作
                     m_isNotFadeing = true;//标记为非融合状态
                     yield return new WaitForFixedUpdate();
                 }
             }
         yield return new WaitForFixedUpdate();
     }
 }
コード例 #7
0
    public static void MoveGO(GameObject TempGO, Vector3 StartPos, Vector3 EndPos, float length)
    {
        AnimationCurve curve1 = null, curve2 = null, curve3 = null;
        curve1 = AnimationCurve.EaseInOut(0, StartPos.x, length, EndPos.x);
        curve2 = AnimationCurve.EaseInOut(0, StartPos.y, length, EndPos.y);
        curve3 = AnimationCurve.EaseInOut(0, StartPos.z, length, EndPos.z);

        AnimationClip clip = new AnimationClip();
        clip.SetCurve("", typeof(Transform), "localPosition.x", curve1);
        clip.SetCurve("", typeof(Transform), "localPosition.y", curve2);
        clip.SetCurve("", typeof(Transform), "localPosition.z", curve3);
        clip.legacy = true;

        if (TempGO.GetComponent<Animation>() == null)
        {
            TempGO.AddComponent<Animation>();
        }

        string clipName = "MoveAnimation";

        Animation animation = TempGO.GetComponent<Animation>();
        if (animation.IsPlaying(clipName))
        {
            //TempGO.animation["AnimationDemo"].time = 0.5f ;
            animation.Sample();
            animation.RemoveClip(clipName);
        }

        animation.AddClip(clip, clipName);
        animation["MoveAnimation"].speed = 1.0F;
        animation.Play("MoveAnimation");
        //TempGO.animation.wrapMode=WrapMode.PingPong;
    }
コード例 #8
0
ファイル: Loupiotte.cs プロジェクト: Juli3nnicolas/TempOcean
    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");
    }
コード例 #9
0
    /// <summary>
    /// Assigns the animation to the character.
    /// </summary>
    static void AssignAnimationToCharacter(AnimationClip clip, GameObject character)
    {
        //create a new controller
        UnityEditorInternal.AnimatorController my_controller = new UnityEditorInternal.AnimatorController();
        my_controller.name = "generic_controller";

        //check if the animator component is already attached to the character
        if (character.GetComponent<Animator>() == null)
            character.AddComponent<Animator>();

        //create the state machine with the animation clip
        StateMachine sm = new StateMachine();
        sm.AddState("default_state");
        sm.GetState(0).SetMotion(0, clip);

        //check if the controller already has a based layer
        if (my_controller.GetLayerCount() == 0)
            my_controller.AddLayer("Base Layer");
        //set the state machine
        my_controller.SetLayerStateMachine(0, sm);

        //assign the controller
        Animator animator = (Animator)character.GetComponent<Animator>();
        UnityEditorInternal.AnimatorController.SetAnimatorController(animator,my_controller);
    }
コード例 #10
0
ファイル: Ulti.cs プロジェクト: sundayliu/HelloWorld-unity3d
    public static void MoveTo(GameObject obj, Vector2 startpos, Vector2 NewPos, float duration, float z)
    {
        Animation anim = obj.GetComponent<Animation>();
        //if (anim.GetClipCount() > 1)
        //{
        //    anim.RemoveClip("Moveto");
        //}
        anim.enabled = true;
        AnimationClip animclip = new AnimationClip();
#if UNITY_5
                animclip.legacy = true;
#endif
        AnimationCurve curvex = AnimationCurve.Linear(0, startpos.x, duration, NewPos.x);
        AnimationCurve curvey = AnimationCurve.Linear(0, startpos.y, duration, NewPos.y);
        AnimationCurve curvez = AnimationCurve.Linear(0, z, duration, z);
        AnimationCurve curvenable = AnimationCurve.Linear(0, 1, duration, 0);

        animclip.SetCurve("", typeof(Transform), "localPosition.x", curvex);
        animclip.SetCurve("", typeof(Transform), "localPosition.y", curvey);
        animclip.SetCurve("", typeof(Transform), "localPosition.z", curvez);
        animclip.SetCurve("", typeof(Animation), "m_Enabled", curvenable);

        anim.AddClip(animclip, "Moveto");
        anim.Play("Moveto");
        Destroy(animclip, duration);
    }
コード例 #11
0
		void CaptureTransform(Transform transform, string path, AnimationClip clip)
		{
			path += transform.name;

			//Debug.Log(path);

			if (position.Value)
			{
				CapturePosition(transform, path, clip);
			}

			if (rotation.Value)
			{
				CaptureRotation(transform, path, clip);
			}

			if (scale.Value)
			{
				CaptureScale(transform, path, clip);
			}

			foreach (Transform child in transform)
			{
				CaptureTransform(child, path + "/", clip);
			}
		}
コード例 #12
0
 static void AnimationClip_events(JSVCall vc)
 {
     if (vc.bGet)
     {
         UnityEngine.AnimationClip _this = (UnityEngine.AnimationClip)vc.csObj;
         var result = _this.events;
         var arrRet = result;
         for (int i = 0; arrRet != null && i < arrRet.Length; i++)
         {
             JSMgr.datax.setObject((int)JSApi.SetType.SaveAndTempTrace, arrRet[i]);
             JSApi.moveSaveID2Arr(i);
         }
         JSApi.setArrayS((int)JSApi.SetType.Rval, (arrRet != null ? arrRet.Length : 0), true);
     }
     else
     {
         UnityEngine.AnimationEvent[] arg0 = JSDataExchangeMgr.GetJSArg <UnityEngine.AnimationEvent[]>(() =>
         {
             int jsObjID = JSApi.getObject((int)JSApi.GetType.Arg);
             int length  = JSApi.getArrayLength(jsObjID);
             var ret     = new UnityEngine.AnimationEvent[length];
             for (var i = 0; i < length; i++)
             {
                 JSApi.getElement(jsObjID, i);
                 ret[i] = (UnityEngine.AnimationEvent)JSMgr.datax.getObject((int)JSApi.GetType.SaveAndRemove);
             }
             return(ret);
         });
         UnityEngine.AnimationClip _this = (UnityEngine.AnimationClip)vc.csObj;
         _this.events = arg0;
     }
 }
コード例 #13
0
    IEnumerator MovePlayer()
    {
        Spell rootSpell = gameObject.GetComponent<Spell>();

        Transform player = rootSpell.m_myCaster.transform;

        // Change animation curves relative to the player's current position
        for (int i = 0; i < x.keys.Length; ++i) {
          x.keys[i].value += player.position.x;
        }
        for (int i = 0; i < y.keys.Length; ++i) {
          y.keys[i].value += player.position.y;
        }
        for (int i = 0; i < z.keys.Length; ++i) {
          z.keys[i].value += player.position.z;
        }

        // Create the clip
        AnimationClip clip = new AnimationClip();
        clip.ClearCurves();
        clip.SetCurve("", typeof(Transform), "localPosition.x", x);
        clip.SetCurve("", typeof(Transform), "localPosition.y", y);
        clip.SetCurve("", typeof(Transform), "localPosition.z", z);

        PlayerController controller = player.GetComponent<PlayerController>();
        player.networkView.RPC("LockPlayer", player.networkView.owner);

        float startTime = Time.time;
        while(Time.time < startTime + duration) {
        }

        return null;
    }
コード例 #14
0
    static void AnimationClip_humanMotion(JSVCall vc)
    {
        UnityEngine.AnimationClip _this = (UnityEngine.AnimationClip)vc.csObj;
        var result = _this.humanMotion;

        JSApi.setBooleanS((int)JSApi.SetType.Rval, (System.Boolean)(result));
    }
コード例 #15
0
    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");
    }
コード例 #16
0
	/// <summary>
	/// Find all idle animations.
	/// </summary>

	void Start ()
	{
		mAnim = GetComponentInChildren<Animation>();
		
		if (mAnim == null)
		{
			Debug.LogWarning(NGUITools.GetHierarchy(gameObject) + " has no Animation component");
			Destroy(this);
		}
		else
		{
			foreach (AnimationState state in mAnim)
			{
				if (state.clip.name == "idle")
				{
					state.layer = 0;
					mIdle = state.clip;
					mAnim.Play(mIdle.name);
				}
				else if (state.clip.name.StartsWith("idle"))
				{
					state.layer = 1;
					mBreaks.Add(state.clip);
				}
			}
		
			// No idle breaks found -- this script is unnecessary
			if (mBreaks.Count == 0) Destroy(this);
		}
	}
コード例 #17
0
			public EventLineContextMenuObject(GameObject animated, AnimationClip clip, float time, int index)
			{
				this.m_Animated = animated;
				this.m_Clip = clip;
				this.m_Time = time;
				this.m_Index = index;
			}
コード例 #18
0
ファイル: ModifyAssetsTools.cs プロジェクト: fengqk/Art
	static void SetEveryBone(AnimationClip clip, string[] allNeedPath)
	{
		Debug.Log("allNeedPath count: " + allNeedPath.Length);

		var AllData = AnimationUtility.GetAllCurves(clip);

		List<string> existedPath = new List<string>();

		foreach (AnimationClipCurveData data in AllData)
		{
			if (!existedPath.Contains(data.path)) { existedPath.Add(data.path);}// Debug.Log(data.path); }
		}

		List<string> needKeyPath = new List<string>();
		foreach (var p in allNeedPath)
		{
			if (!existedPath.Contains(p))
			{
				needKeyPath.Add(p);
			}
		}

		foreach (var p in needKeyPath)
		{
			Debug.Log(p);
		}
	}
コード例 #19
0
        public void AddCurves(AnimationClip animClip)
        {
            foreach(var kvp in curveCache)
            {
                var curves = kvp.Value.Curves;
                //Position curves
                SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(Transform), "localPosition.x", curves[(int)AnimationCurveIndex.LocalPositionX]);
                SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(Transform), "localPosition.y", curves[(int)AnimationCurveIndex.LocalPositionY]);
                SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(Transform), "localPosition.z", curves[(int)AnimationCurveIndex.LocalPositionZ]);

                //Rotation curves
                SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(Transform), "localRotation.x", curves[(int)AnimationCurveIndex.LocalRotationX]);
                SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(Transform), "localRotation.y", curves[(int)AnimationCurveIndex.LocalRotationY]);
                SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(Transform), "localRotation.z", curves[(int)AnimationCurveIndex.LocalRotationZ]);
                SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(Transform), "localRotation.w", curves[(int)AnimationCurveIndex.LocalRotationW]);

                //Scale curves
                SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(Transform), "localScale.x", curves[(int)AnimationCurveIndex.LocalScaleX]);
                SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(Transform), "localScale.y", curves[(int)AnimationCurveIndex.LocalScaleY]);
                SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(Transform), "localScale.z", curves[(int)AnimationCurveIndex.LocalScaleZ]);

                //IsActive curve
                SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(GameObject), "m_IsActive", curves[(int)AnimationCurveIndex.IsActive]);

                if (kvp.Value.IsSpriteKey)
                {
                    //Color Tint curve
                    SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(SpriteRenderer), "m_Color.r", curves[(int)AnimationCurveIndex.ColorR]);
                    SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(SpriteRenderer), "m_Color.g", curves[(int)AnimationCurveIndex.ColorG]);
                    SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(SpriteRenderer), "m_Color.b", curves[(int)AnimationCurveIndex.ColorB]);
                    SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(SpriteRenderer), "m_Color.a", curves[(int)AnimationCurveIndex.ColorA]);
                    SetCurveIfNotEmpty(ref animClip, kvp.Key, typeof(SortingOrderUpdate), "SortingOrder", curves[(int)AnimationCurveIndex.ZIndex]);
                }
            }
        }
コード例 #20
0
 public void ExtractFromPreviewClip(AnimationClip clip)
 {
     AnimationClipSettings animationClipSettings = AnimationUtility.GetAnimationClipSettings(clip);
     if ((this.firstFrame / clip.frameRate) != animationClipSettings.startTime)
     {
         this.firstFrame = this.FixPrecisionErrors(animationClipSettings.startTime * clip.frameRate);
     }
     if ((this.lastFrame / clip.frameRate) != animationClipSettings.stopTime)
     {
         this.lastFrame = this.FixPrecisionErrors(animationClipSettings.stopTime * clip.frameRate);
     }
     this.orientationOffsetY = animationClipSettings.orientationOffsetY;
     this.level = animationClipSettings.level;
     this.cycleOffset = animationClipSettings.cycleOffset;
     this.loopTime = animationClipSettings.loopTime;
     this.loopBlend = animationClipSettings.loopBlend;
     this.loopBlendOrientation = animationClipSettings.loopBlendOrientation;
     this.loopBlendPositionY = animationClipSettings.loopBlendPositionY;
     this.loopBlendPositionXZ = animationClipSettings.loopBlendPositionXZ;
     this.keepOriginalOrientation = animationClipSettings.keepOriginalOrientation;
     this.keepOriginalPositionY = animationClipSettings.keepOriginalPositionY;
     this.keepOriginalPositionXZ = animationClipSettings.keepOriginalPositionXZ;
     this.heightFromFeet = animationClipSettings.heightFromFeet;
     this.mirror = animationClipSettings.mirror;
     this.hasAdditiveReferencePose = animationClipSettings.hasAdditiveReferencePose;
     if ((this.additiveReferencePoseFrame / clip.frameRate) != animationClipSettings.additiveReferencePoseTime)
     {
         this.additiveReferencePoseFrame = this.FixPrecisionErrors(animationClipSettings.additiveReferencePoseTime * clip.frameRate);
     }
 }
コード例 #21
0
ファイル: Extensions.cs プロジェクト: osmanzeki/bmachine
        public static void Play(this Animator animator, AnimationClip clip, float normalizedTime=0f)
        {
            AnimatorOverrideController animatorOverrideController;
                        AnimationClip clipOverride = null;

                        if (animator.runtimeAnimatorController is AnimatorOverrideController) {

                                //animator.runtimeAnimatorController is already overrided just take reference
                                animatorOverrideController = animator.runtimeAnimatorController as AnimatorOverrideController;
                                clipOverride = animatorOverrideController.clips [0].originalClip;
                        } else {
                                //AS RuntimeAnimatorController can't be created at runtime
                                RuntimeAnimatorController dummyController = AnimatorUtilityEx.DUMMY_CONTROLLER;

                                clipOverride = dummyController.animationClips [0];

                                animatorOverrideController = new AnimatorOverrideController ();

                                //bind all clips from animator.runtimeAnimatorController to overrider
                                animatorOverrideController.runtimeAnimatorController = dummyController;
                        }

                        animatorOverrideController [clipOverride] = clip;

                        //to avoid nesting
                        if (animator.runtimeAnimatorController is AnimatorOverrideController) {
                                animator.runtimeAnimatorController = animatorOverrideController.runtimeAnimatorController;
                        }

                        //rebind back
                        animator.runtimeAnimatorController = animatorOverrideController;

                        animator.Play ("Override", 0, normalizedTime);
        }
コード例 #22
0
    public static void createAnimation()
    {
        GameObject go = GameObject.Find(GAME_OBJECT_NAME);
        if (go != null)
            removeGameObjectAndComponents(go);

        Animator animator;
        go = createGameObjects(out animator);
        AnimationClip animationClip = new AnimationClip();
        AnimationUtility.SetAnimationType(animationClip, ModelImporterAnimationType.Generic);

        AnimationCurve activeCurve = new AnimationCurve();
        AnimationCurve positionLineCurve = new AnimationCurve();
        AnimationCurve positionSmoothCurve = new AnimationCurve();

        for (int i = 0; i < stepValues.Length; i++) {
            float time = stepTime * i;
            activeCurve        .AddKey(KeyframeUtil.GetNew(time, stepValues[i]    , TangentMode.Stepped));
            positionLineCurve  .AddKey(KeyframeUtil.GetNew(time, stepValues[i] + 2, TangentMode.Linear));
            positionSmoothCurve.AddKey(KeyframeUtil.GetNew(time, stepValues[i] - 2, TangentMode.Smooth));
        }

        //this will be linear curve, so need to update tangents (should be after keyframes assignments)
        positionLineCurve.UpdateAllLinearTangents();

        animationClip.SetCurve(CUBE1_NAME, typeof(GameObject),"m_IsActive", activeCurve);
        animationClip.SetCurve(CUBE2_NAME, typeof(Transform),"localPosition.x", positionLineCurve);
        animationClip.SetCurve(CUBE2_NAME, typeof(Transform),"localPosition.y", positionSmoothCurve);

        AssetDatabase.CreateAsset(animationClip, ANIMATION_CLIP_PATH);
        AssetDatabase.SaveAssets();
        AddClipToAnimatorComponent(go, animator, animationClip);
    }
コード例 #23
0
 public AnimationClipSerialization(System.Object value, string fieldName, bool arrayItem, NodeBase rootNode)
 {
     this.animationClip = value as UnityEngine.AnimationClip;
     this.fieldName     = fieldName;
     this.arrayItem     = arrayItem;
     this.rootNode      = rootNode;
 }
コード例 #24
0
        public ResourceObject Parse(ByteBuffer bb)
        {
            UnityEngine.AnimationClip clip = new UnityEngine.AnimationClip();

            Schema.AnimationClip _clip = Schema.AnimationClip.GetRootAsAnimationClip(bb);
            clip.frameRate = _clip.FrameRate;
            clip.wrapMode  = (UnityEngine.WrapMode)_clip.WrapMode;
            clip.legacy    = true;

            for (int i = 0; i < _clip.BindingsLength; i++)
            {
                Schema.CurveBinding        bind   = _clip.GetBindings(i);
                Schema.AnimationCurve      _curve = bind.Curve;
                UnityEngine.AnimationCurve curve  = new UnityEngine.AnimationCurve();

                for (int j = 0; j < _curve.KeyFramesLength; j++)
                {
                    Schema.KeyFrame      _kf = _curve.GetKeyFrames(j);
                    UnityEngine.Keyframe kf  = new UnityEngine.Keyframe(_kf.Time, _kf.Value, _kf.InTangent, _kf.OutTangent);
                    kf.tangentMode = _kf.TangentMode;
                    curve.AddKey(kf);
                }
                curve.preWrapMode  = (UnityEngine.WrapMode)_curve.PreWrapMode;
                curve.postWrapMode = (UnityEngine.WrapMode)_curve.PostWrapMode;

                var  assembly = Assembly.Load("UnityEngine");
                Type type     = assembly.GetType(bind.Type);
                clip.SetCurve(bind.Path, type, bind.PropertyName, curve);
            }
            return(new ResourceObjectSingle(clip));
        }
コード例 #25
0
 public static void SampleAnimationClip(GameObject rootGameObject, AnimationClip clip, float time)
 {
   if ((UnityEngine.Object) rootGameObject != (UnityEngine.Object) null)
     AnimationMode.SampleAnimationClip(rootGameObject, clip, time);
   else
     CurveBindingUtility.SampleAnimationClip(clip, time);
 }
コード例 #26
0
    public void AddClip(AnimationClip clip, string newName, float speed, WrapMode wrapMode)
    {
        if (GetAnimationData(newName) != null) Debug.LogWarning("An animation with the name '" + newName + "' already exists.");
        LegacyAnimationData animData = new LegacyAnimationData();
        animData.clip = (AnimationClip)Instantiate(clip);
        if (wrapMode == WrapMode.Default) wrapMode = animator.wrapMode;
        animData.clip.wrapMode = wrapMode;
        animData.clip.name = newName;
        animData.clipName = newName;
        animData.speed = speed;
        animData.originalSpeed = speed;
        animData.length = clip.length;
        animData.wrapMode = wrapMode;

        List<LegacyAnimationData> animationDataList = new List<LegacyAnimationData>(animations);
        animationDataList.Add(animData);
        animations = animationDataList.ToArray();

        animator.AddClip(clip, newName);
        animator[newName].speed = speed;
        animator[newName].wrapMode = wrapMode;

        foreach (AnimationState animState in animator) {
            if (animState.name == newName) animData.animState = animState;
        }
    }
コード例 #27
0
    void CreateAnimatorController(AnimationClip inAnim, AnimationClip outAnim, string animName)
    {
        AnimatorController rac = AnimatorController.CreateAnimatorControllerAtPath("Assets/WindowStateManagement/PageAnimations/Controllers/"+ animName + ".controller");

        //get state machine
        var stateMachine = rac.layers[0].stateMachine;

        //create parameters
        rac.AddParameter("Opening", AnimatorControllerParameterType.Bool);

        //add states
        stateMachine.AddState(inAnim.name);
        stateMachine.AddState(outAnim.name);

        //place clips into states
        AnimatorState inState = stateMachine.states[0].state;
        inState.motion = inAnim;
        inState.speed = inAnimSpeed;

        AnimatorState outState = stateMachine.states[1].state;
        outState.motion = outAnim;
        outState.speed = outAnimSpeed;

        //create transitions
        var inStateExitTransition = inState.AddTransition(outState);
        inStateExitTransition.AddCondition(AnimatorConditionMode.IfNot, 0, "Opening");
    }
コード例 #28
0
// fields

// properties
    static void AnimationClip_length(JSVCall vc)
    {
        UnityEngine.AnimationClip _this = (UnityEngine.AnimationClip)vc.csObj;
        var result = _this.length;

        JSApi.setSingle((int)JSApi.SetType.Rval, (System.Single)(result));
    }
コード例 #29
0
		private static void Internal_CallAnimationClipAwake(AnimationClip clip)
		{
			if (AnimationUtility.onCurveWasModified != null)
			{
				AnimationUtility.onCurveWasModified(clip, default(EditorCurveBinding), AnimationUtility.CurveModifiedType.ClipModified);
			}
		}
コード例 #30
0
ファイル: ClipInfo.cs プロジェクト: Howard-Day/PixelArt
    public void OnGUI()
    {
        clip = EditorGUILayout.ObjectField ("Clip", clip, typeof (AnimationClip), false) as AnimationClip;

        EditorGUILayout.LabelField ("Curves:");
        if (clip != null)
        {
            foreach (var binding in AnimationUtility.GetCurveBindings (clip))
            {
                AnimationCurve curve = AnimationUtility.GetEditorCurve (clip, binding);

                EditorGUILayout.LabelField (binding.path + "/" + binding.propertyName + ", Keys: " + curve.keys.Length);

                for(int i=0;i<curve.keys.Length;i++)
                {
                    EditorGUILayout.LabelField (curve.keys[i].inTangent +" " + curve.keys[i].outTangent);
                    curve.keys[i].inTangent = Mathf.Infinity;
                    curve.keys[i].outTangent = Mathf.Infinity;
                    curve.keys[i].tangentMode = 3;
                }
                AnimationUtility.SetEditorCurve(clip,binding,curve);

            }
        }
    }
コード例 #31
0
ファイル: FusionAnime.cs プロジェクト: yodaka/UnityScripts
 void CopyClip(string importedPath, string copyPath)
 {
     AnimationClip newClip = new AnimationClip();
     newClip.name = outputName;
     AssetDatabase.CreateAsset(newClip, copyPath);
     AssetDatabase.Refresh();
 }
コード例 #32
0
 void CaptureRotation(Transform transform, string path, AnimationClip clip)
 {
     SetConstantCurve(clip, path, "localRotation.x", transform.localRotation.x);
     SetConstantCurve(clip, path, "localRotation.y", transform.localRotation.y);
     SetConstantCurve(clip, path, "localRotation.z", transform.localRotation.z);
     SetConstantCurve(clip, path, "localRotation.w", transform.localRotation.w);
 }
コード例 #33
0
 public void doAttack(BotController bot, AnimationClip attackAnimation)
 {
     this.attackAnimation = attackAnimation;
     if (bot != null) {
         impactBot(bot, attackAnimation);
     }
 }
コード例 #34
0
    // Use this for initialization
    void Start()
    {
        m_InitialPosition = gameObject.transform.localPosition;
        m_RelPosition.Set(0, 0, 0);
        m_Translations = new Vector3[3];
        m_Translations[0].Set(m_Speed, 0, 0);
        m_Translations[1].Set(0, m_Speed, 0);
        m_Translations[2].Set(0, 0, m_Speed);

        gameObject.AddComponent<Animation>();
        gameObject.animation.animatePhysics = true;
        m_Forward = new AnimationClip();

        var curvex = new AnimationCurve();
        var curvey = new AnimationCurve();
        var curvez = new AnimationCurve();
        var minpos = m_InitialPosition+m_MinIncrement;
        var maxpos = m_InitialPosition-m_MaxIncrement;
        float dist = (minpos-maxpos).magnitude;
        m_MaxTime = dist/m_Speed;
        curvex.AddKey(0f, minpos.x);
        curvex.AddKey(dist/m_Speed, maxpos.x);
        curvey.AddKey(0f, minpos.y);
        curvey.AddKey(dist/m_Speed, maxpos.y);
        curvez.AddKey(0f, minpos.z);
        curvez.AddKey(dist/m_Speed, maxpos.z);
        m_Forward.wrapMode = WrapMode.ClampForever;

        m_Forward.SetCurve("", typeof(Transform), "localPosition.x", curvex);
        m_Forward.SetCurve("", typeof(Transform), "localPosition.y", curvey);
        m_Forward.SetCurve("", typeof(Transform), "localPosition.z", curvez);
        this.animation.AddClip(m_Forward, "Forward");
        this.animation.Play("Forward");
        m_ForwardState = this.animation["Forward"];
    }
コード例 #35
0
		public static RotationCurveInterpolation.State GetCurveState(AnimationClip clip, EditorCurveBinding[] selection)
		{
			RotationCurveInterpolation.State result;
			result.allAreNonBaked = true;
			result.allAreBaked = false;
			result.allAreRotations = false;
			for (int i = 0; i < selection.Length; i++)
			{
				EditorCurveBinding data = selection[i];
				RotationCurveInterpolation.Mode modeFromCurveData = RotationCurveInterpolation.GetModeFromCurveData(data);
				if (modeFromCurveData == RotationCurveInterpolation.Mode.NonBaked)
				{
					result.allAreNonBaked = false;
				}
				else
				{
					if (modeFromCurveData == RotationCurveInterpolation.Mode.Baked)
					{
						result.allAreBaked = false;
					}
					else
					{
						result.allAreRotations = false;
					}
				}
			}
			return result;
		}
コード例 #36
0
	void Start()
	{
		if (Timer == null) Timer = GetComponent<CountdownTimer>();
		if (Timer == null) 
		{
			enabled = false;
			return;
		}
		
		if (Target == null) Target = animation;
		if (Target == null) 
		{
			enabled = false;
			return;
		}
		
		cl = animation.GetClip(AnimationName);
		if (cl == null) 
		{
			Debug.LogError("Animation " + AnimationName + " not found on object");
			return;
		}
		
		if (!Blend)
		{
			animation.Play(AnimationName);
		}
		else
		{
			animation.Blend(AnimationName, BlendWeight, 0f);
		}
		
		st = animation[AnimationName];
		st.speed = 0;
	}
コード例 #37
0
    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");
        }
    }
コード例 #38
0
        public static string GetAnimationClipPath(UnityEngine.AnimationClip clip)
        {
            var path = UnityEditor.AssetDatabase.GetAssetPath(clip);

            path = path.Substring(0, path.LastIndexOf(".")) + "_" + clip.name + ".ani.bin";
            path = PathHelper.CheckFileName(path);
            return(path);
        }
コード例 #39
0
 static public int set_wrapMode(IntPtr l)
 {
     UnityEngine.AnimationClip o = (UnityEngine.AnimationClip)checkSelf(l);
     UnityEngine.WrapMode      v;
     checkEnum(l, 2, out v);
     o.wrapMode = v;
     return(0);
 }
コード例 #40
0
 static public int set_localBounds(IntPtr l)
 {
     UnityEngine.AnimationClip o = (UnityEngine.AnimationClip)checkSelf(l);
     UnityEngine.Bounds        v;
     checkType(l, 2, out v);
     o.localBounds = v;
     return(0);
 }
コード例 #41
0
 static public void FastSetter(this UnityEngine.Animation o, string propertyName, UnityEngine.AnimationClip value)
 {
     switch (propertyName)
     {
     case "clip":
         o.clip = value; return;
     }
     LBoot.LogUtil.Error("UnityEngine.Animation no Setter Found : " + propertyName);
 }
コード例 #42
0
        protected override void Serialize(UnityEngine.Object sourceAsset)
        {
            this._animationClip = sourceAsset as UnityEngine.AnimationClip;

            this._animationTargets.Clear();
            this._bufferWriter = new BinaryWriter(new MemoryStream());

            _exportAnimation(_animationClip);
        }
コード例 #43
0
    static public int set_frameRate(IntPtr l)
    {
        UnityEngine.AnimationClip o = (UnityEngine.AnimationClip)checkSelf(l);
        float v;

        checkType(l, 2, out v);
        o.frameRate = v;
        return(0);
    }
コード例 #44
0
 /// <summary>
 /// Write the specified value using the writer.
 /// </summary>
 /// <param name="value">Value.</param>
 /// <param name="writer">Writer.</param>
 public override void Write(object value, ISaveGameWriter writer)
 {
     UnityEngine.AnimationClip animationClip = (UnityEngine.AnimationClip)value;
     writer.WriteProperty("frameRate", animationClip.frameRate);
     writer.WriteProperty("wrapMode", animationClip.wrapMode);
     writer.WriteProperty("localBounds", animationClip.localBounds);
     writer.WriteProperty("legacy", animationClip.legacy);
     writer.WriteProperty("events", animationClip.events);
     writer.WriteProperty("name", animationClip.name);
     writer.WriteProperty("hideFlags", animationClip.hideFlags);
 }
コード例 #45
0
 static public int get_wrapMode(IntPtr l)
 {
     try {
         UnityEngine.AnimationClip self = (UnityEngine.AnimationClip)checkSelf(l);
         pushEnum(l, (int)self.wrapMode);
         return(1);
     }
     catch (Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return(0);
     }
 }
コード例 #46
0
 static public int get_events(IntPtr l)
 {
     try {
         UnityEngine.AnimationClip self = (UnityEngine.AnimationClip)checkSelf(l);
         pushValue(l, true);
         pushValue(l, self.events);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
コード例 #47
0
 static public int ClearCurves(IntPtr l)
 {
     try{
         UnityEngine.AnimationClip self = (UnityEngine.AnimationClip)checkSelf(l);
         self.ClearCurves();
         return(0);
     }
     catch (Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return(0);
     }
 }
コード例 #48
0
 static public int get_events(IntPtr l)
 {
     try {
         UnityEngine.AnimationClip self = (UnityEngine.AnimationClip)checkSelf(l);
         pushValue(l, self.events);
         return(1);
     }
     catch (Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return(0);
     }
 }
コード例 #49
0
 static public int EnsureQuaternionContinuity(IntPtr l)
 {
     try{
         UnityEngine.AnimationClip self = (UnityEngine.AnimationClip)checkSelf(l);
         self.EnsureQuaternionContinuity();
         return(0);
     }
     catch (Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return(0);
     }
 }
コード例 #50
0
    static bool Animation_RemoveClip__AnimationClip(JSVCall vc, int argc)
    {
        int len = argc;

        if (len == 1)
        {
            UnityEngine.AnimationClip arg0 = (UnityEngine.AnimationClip)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
            ((UnityEngine.Animation)vc.csObj).RemoveClip(arg0);
        }

        return(true);
    }
コード例 #51
0
 static public int get_wrapMode(IntPtr l)
 {
     try {
         UnityEngine.AnimationClip self = (UnityEngine.AnimationClip)checkSelf(l);
         pushValue(l, true);
         pushEnum(l, (int)self.wrapMode);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
コード例 #52
0
 static public int EnsureQuaternionContinuity(IntPtr l)
 {
     try {
         UnityEngine.AnimationClip self = (UnityEngine.AnimationClip)checkSelf(l);
         self.EnsureQuaternionContinuity();
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
コード例 #53
0
 static public int ClearCurves(IntPtr l)
 {
     try {
         UnityEngine.AnimationClip self = (UnityEngine.AnimationClip)checkSelf(l);
         self.ClearCurves();
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
コード例 #54
0
        public void OneTimeSetup()
        {
            var skeletonNodes = new[]
            {
                new SkeletonNode {
                    ParentIndex = -1, Id = string.Empty, AxisIndex = -1
                },
                new SkeletonNode {
                    ParentIndex = 0, Id = "Child1", AxisIndex = -1
                },
                new SkeletonNode {
                    ParentIndex = 0, Id = "Child2", AxisIndex = -1
                }
            };

            RigDefinition = RigBuilder.CreateRigDefinition(skeletonNodes);

            var r        = new Mathematics.Random(0x12345678);
            var range    = new float3(100);
            var fullClip = new UnityEngine.AnimationClip();

            // add some error into the clip, so it is not perfectly frame aligned
            float clipDuration = clipFrames / fullClip.frameRate + 0.123f / fullClip.frameRate;


            CreateLinearTranslate(fullClip, string.Empty, float3.zero, new float3(0, 1, 0), clipDuration);
            CreateLinearTranslate(fullClip, "Child1", r.NextFloat3(-range, range), r.NextFloat3(-range, range), clipDuration);
            CreateLinearTranslate(fullClip, "Child2", r.NextFloat3(-range, range), r.NextFloat3(-range, range), clipDuration);
            CreateRotation(fullClip, string.Empty, quaternion.identity, r.NextQuaternionRotation(), clipDuration);
            CreateRotation(fullClip, "Child1", r.NextQuaternionRotation(), r.NextQuaternionRotation(), clipDuration);
            CreateRotation(fullClip, "Child2", r.NextQuaternionRotation(), r.NextQuaternionRotation(), clipDuration);
            CreateScale(fullClip, string.Empty, new float3(1), new float3(1), clipDuration);
            CreateScale(fullClip, "Child1", new float3(1), new float3(2), clipDuration);
            CreateScale(fullClip, "Child2", new float3(2), new float3(3), clipDuration);
            FullAnimationClip = ClipBuilder.AnimationClipToDenseClip(fullClip);

            var partialClip = new UnityEngine.AnimationClip();

            CreateLinearTranslate(partialClip, "Child1", r.NextFloat3(-range, range), r.NextFloat3(-range, range), clipDuration);
            CreateRotation(partialClip, string.Empty, quaternion.identity, r.NextQuaternionRotation(), clipDuration);
            CreateRotation(partialClip, "Child2", quaternion.identity, r.NextQuaternionRotation(), clipDuration);
            CreateScale(partialClip, string.Empty, float3.zero, new float3(1), clipDuration);
            PartialAnimationClip = ClipBuilder.AnimationClipToDenseClip(partialClip);

            var alignedClip = new UnityEngine.AnimationClip();

            CreateLinearTranslate(alignedClip, string.Empty, float3.zero, new float3(0, 1, 0), 1.0f);
            CreateLinearTranslate(alignedClip, "Child1", r.NextFloat3(-range, range), r.NextFloat3(-range, range), 1.0f);
            CreateLinearTranslate(alignedClip, "Child2", r.NextFloat3(-range, range), r.NextFloat3(-range, range), 1.0f);
            CreateRotation(alignedClip, string.Empty, quaternion.identity, r.NextQuaternionRotation(), 1.0f);
            AlignedClip = ClipBuilder.AnimationClipToDenseClip(alignedClip);
        }
コード例 #55
0
 static public int constructor(IntPtr l)
 {
     try {
         UnityEngine.AnimationClip o;
         o = new UnityEngine.AnimationClip();
         pushValue(l, o);
         return(1);
     }
     catch (Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return(0);
     }
 }
コード例 #56
0
    static bool Animation_AddClip__AnimationClip__String(JSVCall vc, int argc)
    {
        int len = argc;

        if (len == 2)
        {
            UnityEngine.AnimationClip arg0 = (UnityEngine.AnimationClip)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
            System.String             arg1 = (System.String)JSApi.getStringS((int)JSApi.GetType.Arg);
            ((UnityEngine.Animation)vc.csObj).AddClip(arg0, arg1);
        }

        return(true);
    }
コード例 #57
0
 static public int constructor(IntPtr l)
 {
     LuaDLL.lua_remove(l, 1);
     UnityEngine.AnimationClip o;
     if (matchType(l, 1))
     {
         o = new UnityEngine.AnimationClip();
         pushObject(l, o);
         return(1);
     }
     LuaDLL.luaL_error(l, "New object failed.");
     return(0);
 }
コード例 #58
0
 static public int constructor(IntPtr l)
 {
     try {
         UnityEngine.AnimationClip o;
         o = new UnityEngine.AnimationClip();
         pushValue(l, true);
         pushValue(l, o);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
コード例 #59
0
    static bool GameObject_SampleAnimation__AnimationClip__Single(JSVCall vc, int argc)
    {
        int len = argc;

        if (len == 2)
        {
            UnityEngine.AnimationClip arg0 = (UnityEngine.AnimationClip)JSMgr.datax.getObject((int)JSApi.GetType.Arg);
            System.Single             arg1 = (System.Single)JSApi.getSingle((int)JSApi.GetType.Arg);
            ((UnityEngine.GameObject)vc.csObj).SampleAnimation(arg0, arg1);
        }

        return(true);
    }
コード例 #60
0
ファイル: Animation.cs プロジェクト: U3DC/SanAndreasUnity-1
//		public static AnimationCurve[] GetAllCurvesForClip (UnityEngine.AnimationClip clip)
//		{
//			if (s_curvesPerClip.ContainsKey (clip)) {
//				return s_curvesPerClip [clip].ToArray ();
//			} else {
//				return new AnimationCurve[0];
//			}
//		}

        public static void RemovePositionCurves(UnityEngine.AnimationClip clip, FrameContainer frames)
        {
            foreach (var frame in frames)
            {
                string bonePath = frame.Path;

//				foreach (var translateAxis in s_translateAxes) {
//					clip.SetCurve (bonePath, typeof(Transform), "localPosition." + translateAxis.Name, null);
//				}

                clip.SetCurve(bonePath, typeof(Transform), "m_LocalPosition", null);
            }
        }