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;
        }
Пример #2
0
 public KeyIdentifier(CurveRenderer _renderer, int _curveId, int _keyIndex, EditorCurveBinding _binding)
 {
     this.renderer = _renderer;
     this.curveId = _curveId;
     this.key = _keyIndex;
     this.binding = _binding;
 }
		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;
		}
 private static void PrepareHierarchy(EditorCurveBinding curveBinding)
 {
   GameObject orGetGameObject = CurveBindingUtility.CreateOrGetGameObject(curveBinding.path);
   if (!((UnityEngine.Object) orGetGameObject.GetComponent(curveBinding.type) == (UnityEngine.Object) null))
     return;
   orGetGameObject.AddComponent(curveBinding.type);
 }
 private TreeViewItem AddAnimatableObjectToHierarchy(GameObject root, EditorCurveBinding[] curveBindings, TreeViewItem parentNode, string path)
 {
     TreeViewItem item = new AddCurvesPopupObjectNode(parentNode, path, GetClassName(root, curveBindings[0])) {
         icon = AssetPreview.GetMiniThumbnail(AnimationUtility.GetAnimatedObject(root, curveBindings[0]))
     };
     List<TreeViewItem> visibleItems = new List<TreeViewItem>();
     List<EditorCurveBinding> list2 = new List<EditorCurveBinding>();
     for (int i = 0; i < curveBindings.Length; i++)
     {
         EditorCurveBinding binding = curveBindings[i];
         list2.Add(binding);
         if ((i == (curveBindings.Length - 1)) || (AnimationWindowUtility.GetPropertyGroupName(curveBindings[i + 1].propertyName) != AnimationWindowUtility.GetPropertyGroupName(binding.propertyName)))
         {
             TreeViewItem item2 = this.CreateNode(list2.ToArray(), item);
             if (item2 != null)
             {
                 visibleItems.Add(item2);
             }
             list2.Clear();
         }
     }
     visibleItems.Sort();
     TreeViewUtility.SetChildParentReferences(visibleItems, item);
     return item;
 }
Пример #6
0
 public KeyIdentifier(AnimationCurve _curve, int _curveId, int _keyIndex, EditorCurveBinding _binding)
 {
     this.curve = _curve;
     this.curveId = _curveId;
     this.key = _keyIndex;
     this.binding = _binding;
 }
 public static void CreateDefaultCurves(AnimationWindowState state, EditorCurveBinding[] properties)
 {
   AnimationClip activeAnimationClip = state.activeAnimationClip;
   GameObject activeRootGameObject = state.activeRootGameObject;
   properties = RotationCurveInterpolation.ConvertRotationPropertiesToDefaultInterpolation(state.activeAnimationClip, properties);
   foreach (EditorCurveBinding property in properties)
     state.SaveCurve(AnimationWindowUtility.CreateDefaultCurve(activeAnimationClip, activeRootGameObject, property));
 }
Пример #8
0
		public static void SetEditorCurve(AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve)
		{
			AnimationUtility.Internal_SetEditorCurve(clip, binding, curve);
			if (AnimationUtility.onCurveWasModified != null)
			{
				AnimationUtility.onCurveWasModified(clip, binding, (curve == null) ? AnimationUtility.CurveModifiedType.CurveDeleted : AnimationUtility.CurveModifiedType.CurveModified);
			}
		}
Пример #9
0
 public static System.Type GetEditorCurveValueType(GameObject rootGameObject, EditorCurveBinding curveBinding)
 {
     if (rootGameObject != null)
     {
         return AnimationUtility.GetEditorCurveValueType(rootGameObject, curveBinding);
     }
     return GetEditorCurveValueType(curveBinding);
 }
Пример #10
0
 public static object GetCurrentValue(GameObject rootGameObject, EditorCurveBinding curveBinding)
 {
     if (rootGameObject != null)
     {
         return AnimationWindowUtility.GetCurrentValue(rootGameObject, curveBinding);
     }
     return GetCurrentValue(curveBinding);
 }
Пример #11
0
		public static void SetObjectReferenceCurve(AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes)
		{
			AnimationUtility.Internal_SetObjectReferenceCurve(clip, binding, keyframes);
			if (AnimationUtility.onCurveWasModified != null)
			{
				AnimationUtility.onCurveWasModified(clip, binding, (keyframes == null) ? AnimationUtility.CurveModifiedType.CurveDeleted : AnimationUtility.CurveModifiedType.CurveModified);
			}
		}
Пример #12
0
 public static int GetCurveGroupID(AnimationClip clip, EditorCurveBinding curveData)
 {
   if (curveData.type != typeof (Transform))
     return -1;
   int num = !((UnityEngine.Object) clip == (UnityEngine.Object) null) ? clip.GetInstanceID() : 0;
   string str = curveData.propertyName.Substring(0, curveData.propertyName.Length - 1);
   return num * 19603 ^ curveData.path.GetHashCode() * 729 ^ curveData.type.GetHashCode() * 27 ^ str.GetHashCode();
 }
 private static void AddRotationPropertyModification(IAnimationRecordingState state, EditorCurveBinding baseBinding, UndoPropertyModification modification)
 {
     if (modification.previousValue != null)
     {
         EditorCurveBinding binding = baseBinding;
         binding.propertyName = modification.previousValue.propertyPath;
         AnimationMode.AddPropertyModification(binding, modification.previousValue, modification.keepPrefabOverride);
     }
 }
 public AnimationClipCurveData(EditorCurveBinding binding)
 {
   this.path = binding.path;
   this.type = binding.type;
   this.propertyName = binding.propertyName;
   this.curve = (AnimationCurve) null;
   this.classID = binding.m_ClassID;
   this.scriptInstanceID = binding.m_ScriptInstanceID;
 }
 private static EditorCurveBinding[] GenerateTransformCurveBindingArray(string path, string property, System.Type type, int count)
 {
     EditorCurveBinding[] bindingArray = new EditorCurveBinding[count];
     for (int i = 0; i < count; i++)
     {
         bindingArray[i] = EditorCurveBinding.FloatCurve(path, type, property + kPostFix[i]);
     }
     return bindingArray;
 }
Пример #16
0
 public static int GetCurveGroupID(AnimationClip clip, EditorCurveBinding curveData)
 {
     if (curveData.type != typeof(Transform))
     {
         return -1;
     }
     int num = (clip != null) ? clip.GetInstanceID() : 0;
     string str = curveData.propertyName.Substring(0, curveData.propertyName.Length - 1);
     return ((((num * 0x4c93) ^ (curveData.path.GetHashCode() * 0x2d9)) ^ (curveData.type.GetHashCode() * 0x1b)) ^ str.GetHashCode());
 }
 public static RotationCurveInterpolation.Mode GetModeFromCurveData(EditorCurveBinding data)
 {
   if (AnimationWindowUtility.IsTransformType(data.type) && data.propertyName.StartsWith("localEulerAngles"))
   {
     if (data.propertyName.StartsWith("localEulerAnglesBaked"))
       return RotationCurveInterpolation.Mode.Baked;
     return data.propertyName.StartsWith("localEulerAnglesRaw") ? RotationCurveInterpolation.Mode.RawEuler : RotationCurveInterpolation.Mode.NonBaked;
   }
   return AnimationWindowUtility.IsTransformType(data.type) && data.propertyName.StartsWith("m_LocalRotation") ? RotationCurveInterpolation.Mode.RawQuaternions : RotationCurveInterpolation.Mode.Undefined;
 }
Пример #18
0
		public static int GetCurveGroupID(AnimationClip clip, EditorCurveBinding curveData)
		{
			if (curveData.type != typeof(Transform))
			{
				return -1;
			}
			int num = (!(clip == null)) ? clip.GetInstanceID() : 0;
			string text = curveData.propertyName.Substring(0, curveData.propertyName.Length - 1);
			return num * 19603 ^ curveData.path.GetHashCode() * 729 ^ curveData.type.GetHashCode() * 27 ^ text.GetHashCode();
		}
		public static void CreateDefaultCurves(AnimationWindowState state, EditorCurveBinding[] properties)
		{
			AnimationClip activeAnimationClip = state.m_ActiveAnimationClip;
			GameObject rootGameObject = state.m_RootGameObject;
			properties = RotationCurveInterpolation.ConvertRotationPropertiesToDefaultInterpolation(state.m_ActiveAnimationClip, properties);
			EditorCurveBinding[] array = properties;
			for (int i = 0; i < array.Length; i++)
			{
				EditorCurveBinding binding = array[i];
				state.SaveCurve(AnimationWindowUtility.CreateDefaultCurve(activeAnimationClip, rootGameObject, binding));
			}
		}
 internal static EditorCurveBinding[] ConvertRotationPropertiesToInterpolationType(EditorCurveBinding[] selection, Mode newInterpolationMode)
 {
     if ((selection.Length == 4) && (GetModeFromCurveData(selection[0]) == Mode.RawQuaternions))
     {
         EditorCurveBinding[] bindingArray = new EditorCurveBinding[] { selection[0], selection[1], selection[2] };
         string prefixForInterpolation = GetPrefixForInterpolation(newInterpolationMode);
         bindingArray[0].propertyName = prefixForInterpolation + ".x";
         bindingArray[1].propertyName = prefixForInterpolation + ".y";
         bindingArray[2].propertyName = prefixForInterpolation + ".z";
         return bindingArray;
     }
     return selection;
 }
 private void ChangeRotationInterpolation(object interpolationMode)
 {
     RotationCurveInterpolation.Mode newInterpolationMode = (RotationCurveInterpolation.Mode) ((int) interpolationMode);
     AnimationWindowCurve[] curveArray = this.state.activeCurves.ToArray();
     EditorCurveBinding[] curveBindings = new EditorCurveBinding[curveArray.Length];
     for (int i = 0; i < curveArray.Length; i++)
     {
         curveBindings[i] = curveArray[i].binding;
     }
     RotationCurveInterpolation.SetInterpolation(this.state.activeAnimationClip, curveBindings, newInterpolationMode);
     this.MaintainTreeviewStateAfterRotationInterpolation(newInterpolationMode);
     this.state.hierarchyData.ReloadData();
 }
		private static PropertyModification FindPropertyModification(GameObject root, UndoPropertyModification[] modifications, EditorCurveBinding binding)
		{
			for (int i = 0; i < modifications.Length; i++)
			{
				EditorCurveBinding lhs;
				AnimationUtility.PropertyModificationToEditorCurveBinding(modifications[i].propertyModification, root, out lhs);
				if (lhs == binding)
				{
					return modifications[i].propertyModification;
				}
			}
			return null;
		}
 private static PropertyModification FindPropertyModification(GameObject root, UndoPropertyModification[] modifications, EditorCurveBinding binding)
 {
   for (int index = 0; index < modifications.Length; ++index)
   {
     if (modifications[index].currentValue == null || !(modifications[index].currentValue.target is Animator))
     {
       EditorCurveBinding binding1;
       AnimationUtility.PropertyModificationToEditorCurveBinding(modifications[index].previousValue, root, out binding1);
       if (binding1 == binding)
         return modifications[index].previousValue;
     }
   }
   return (PropertyModification) null;
 }
Пример #24
0
    private void FillModelWithCurves(EditorCurveBinding[] curves)
    {
        foreach (EditorCurveBinding curveData in curves) {
            string key = curveData.path;

            if (paths.ContainsKey(key)) {
                ((ArrayList)paths[key]).Add(curveData);
            } else {
                ArrayList newProperties = new ArrayList();
                newProperties.Add(curveData);
                paths.Add(key, newProperties);
                pathsKeys.Add(key);
            }
        }
    }
 private static void CollectRotationModifications(AnimationWindowState state, ref UndoPropertyModification[] modifications, ref Dictionary<object, AnimationRecording.RotationModification> rotationModifications)
 {
   List<UndoPropertyModification> propertyModificationList = new List<UndoPropertyModification>();
   foreach (UndoPropertyModification propertyModification in modifications)
   {
     EditorCurveBinding binding = new EditorCurveBinding();
     PropertyModification previousValue = propertyModification.previousValue;
     AnimationUtility.PropertyModificationToEditorCurveBinding(previousValue, state.activeRootGameObject, out binding);
     if (binding.propertyName.StartsWith("m_LocalRotation"))
     {
       AnimationRecording.RotationModification rotationModification;
       if (!rotationModifications.TryGetValue((object) previousValue.target, out rotationModification))
       {
         rotationModification = new AnimationRecording.RotationModification();
         rotationModifications[(object) previousValue.target] = rotationModification;
       }
       if (binding.propertyName.EndsWith("x"))
         rotationModification.x = propertyModification;
       else if (binding.propertyName.EndsWith("y"))
         rotationModification.y = propertyModification;
       else if (binding.propertyName.EndsWith("z"))
         rotationModification.z = propertyModification;
       else if (binding.propertyName.EndsWith("w"))
         rotationModification.w = propertyModification;
       rotationModification.lastQuatModification = propertyModification;
     }
     else if (previousValue.propertyPath.StartsWith("m_LocalEulerAnglesHint"))
     {
       AnimationRecording.RotationModification rotationModification;
       if (!rotationModifications.TryGetValue((object) previousValue.target, out rotationModification))
       {
         rotationModification = new AnimationRecording.RotationModification();
         rotationModifications[(object) previousValue.target] = rotationModification;
       }
       if (previousValue.propertyPath.EndsWith("x"))
         rotationModification.eulerX = propertyModification;
       else if (previousValue.propertyPath.EndsWith("y"))
         rotationModification.eulerY = propertyModification;
       else if (previousValue.propertyPath.EndsWith("z"))
         rotationModification.eulerZ = propertyModification;
     }
     else
       propertyModificationList.Add(propertyModification);
   }
   if (propertyModificationList.Count <= 0)
     return;
   modifications = propertyModificationList.ToArray();
 }
 internal static EditorCurveBinding[] ConvertRotationPropertiesToInterpolationType(EditorCurveBinding[] selection, RotationCurveInterpolation.Mode newInterpolationMode)
 {
   if (selection.Length != 4 || RotationCurveInterpolation.GetModeFromCurveData(selection[0]) != RotationCurveInterpolation.Mode.RawQuaternions)
     return selection;
   EditorCurveBinding[] editorCurveBindingArray = new EditorCurveBinding[3]
   {
     selection[0],
     selection[1],
     selection[2]
   };
   string forInterpolation = RotationCurveInterpolation.GetPrefixForInterpolation(newInterpolationMode);
   editorCurveBindingArray[0].propertyName = forInterpolation + ".x";
   editorCurveBindingArray[1].propertyName = forInterpolation + ".y";
   editorCurveBindingArray[2].propertyName = forInterpolation + ".z";
   return editorCurveBindingArray;
 }
Пример #27
0
 private static PropertyModification FindPropertyModification(GameObject root, UndoPropertyModification[] modifications, EditorCurveBinding binding)
 {
     for (int i = 0; i < modifications.Length; i++)
     {
         if (!(modifications[i].currentValue.target is Animator))
         {
             EditorCurveBinding binding2;
             AnimationUtility.PropertyModificationToEditorCurveBinding(modifications[i].previousValue, root, out binding2);
             if (binding2 == binding)
             {
                 return modifications[i].previousValue;
             }
         }
     }
     return null;
 }
		public static AnimationWindowCurve CreateDefaultCurve(AnimationClip clip, GameObject rootGameObject, EditorCurveBinding binding)
		{
			Type editorCurveValueType = AnimationUtility.GetEditorCurveValueType(rootGameObject, binding);
			AnimationWindowCurve animationWindowCurve = new AnimationWindowCurve(clip, binding, editorCurveValueType);
			object currentValue = AnimationWindowUtility.GetCurrentValue(rootGameObject, binding);
			if (clip.length == 0f)
			{
				AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, currentValue, editorCurveValueType, AnimationKeyTime.Time(0f, clip.frameRate));
			}
			else
			{
				AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, currentValue, editorCurveValueType, AnimationKeyTime.Time(0f, clip.frameRate));
				AnimationWindowUtility.AddKeyframeToCurve(animationWindowCurve, currentValue, editorCurveValueType, AnimationKeyTime.Time(clip.length, clip.frameRate));
			}
			return animationWindowCurve;
		}
 public static RotationCurveInterpolation.State GetCurveState(AnimationClip clip, EditorCurveBinding[] selection)
 {
   RotationCurveInterpolation.State state;
   state.allAreRaw = true;
   state.allAreNonBaked = true;
   state.allAreBaked = true;
   state.allAreRotations = true;
   foreach (EditorCurveBinding data in selection)
   {
     RotationCurveInterpolation.Mode modeFromCurveData = RotationCurveInterpolation.GetModeFromCurveData(data);
     state.allAreBaked &= modeFromCurveData == RotationCurveInterpolation.Mode.Baked;
     state.allAreNonBaked &= modeFromCurveData == RotationCurveInterpolation.Mode.NonBaked;
     state.allAreRaw &= modeFromCurveData == RotationCurveInterpolation.Mode.RawEuler;
     state.allAreRotations &= modeFromCurveData != RotationCurveInterpolation.Mode.Undefined;
   }
   return state;
 }
Пример #30
0
 static AnimationClip Duplicate(AnimationClip src, AnimationClip dest)
 {
     AnimationClipCurveData[] curveDatas = AnimationUtility.GetAllCurves(src, true);
     foreach(var data in curveDatas)
     {
         EditorCurveBinding curve = new EditorCurveBinding();
         curve.path = data.path;
         curve.type = data.type;
         curve.propertyName = data.propertyName;
         AnimationUtility.SetEditorCurve(
             dest,
             curve,
             data.curve
             );
     }
     return dest;
 }
Пример #31
0
 public static Type GetEditorCurveValueType(GameObject root, EditorCurveBinding binding)
 {
     return(AnimationUtility.INTERNAL_CALL_GetEditorCurveValueType(root, ref binding));
 }
Пример #32
0
 // Binds the property and returns the type of the bound value (Can be used to display special UI for it and to enforce correct drag and drop)
 // null if it can't be bound.
 public static System.Type GetEditorCurveValueType(GameObject root, EditorCurveBinding binding)
 {
     return(Internal_GetGameObjectEditorCurveValueType(root, binding));
 }
Пример #33
0
 private static extern AnimationCurve INTERNAL_CALL_GetEditorCurve(AnimationClip clip, ref EditorCurveBinding binding);
 public ChangedCurve(AnimationCurve curve, int curveId, EditorCurveBinding binding)
 {
     this.curve   = curve;
     this.curveId = curveId;
     this.binding = binding;
 }
Пример #35
0
 public static extern Type PropertyModificationToEditorCurveBinding(PropertyModification modification, GameObject gameObject, out EditorCurveBinding binding);
Пример #36
0
 extern public static ObjectReferenceKeyframe[] GetObjectReferenceCurve([NotNull] AnimationClip clip, EditorCurveBinding binding);
Пример #37
0
 extern private static void Internal_SetObjectReferenceCurve([NotNull] AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes, bool updateMuscleClip);
Пример #38
0
 private static void Internal_SetObjectReferenceCurve(AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes)
 {
     AnimationUtility.INTERNAL_CALL_Internal_SetObjectReferenceCurve(clip, ref binding, keyframes);
 }
Пример #39
0
 private static extern bool INTERNAL_CALL_GetFloatValue(GameObject root, ref EditorCurveBinding binding, out float data);
Пример #40
0
 public static bool GetFloatValue(GameObject root, EditorCurveBinding binding, out float data)
 {
     return(AnimationUtility.INTERNAL_CALL_GetFloatValue(root, ref binding, out data));
 }
Пример #41
0
 public static AnimationCurve GetEditorCurve(AnimationClip clip, string relativePath, Type type, string propertyName)
 {
     return(AnimationUtility.GetEditorCurve(clip, EditorCurveBinding.FloatCurve(relativePath, type, propertyName)));
 }
Пример #42
0
 public static void SetEditorCurve(AnimationClip clip, string relativePath, Type type, string propertyName, AnimationCurve curve)
 {
     AnimationUtility.SetEditorCurve(clip, EditorCurveBinding.FloatCurve(relativePath, type, propertyName), curve);
 }
Пример #43
0
 private static extern void INTERNAL_CALL_Internal_SetEditorCurve(AnimationClip clip, ref EditorCurveBinding binding, AnimationCurve curve, bool syncEditorCurve);
Пример #44
0
 private static void Internal_SetEditorCurve(AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve, bool syncEditorCurve)
 {
     AnimationUtility.INTERNAL_CALL_Internal_SetEditorCurve(clip, ref binding, curve, syncEditorCurve);
 }
Пример #45
0
 extern public static AnimationCurve GetEditorCurve([NotNull] AnimationClip clip, EditorCurveBinding binding);
Пример #46
0
 private static extern void INTERNAL_CALL_Internal_SetObjectReferenceCurve(AnimationClip clip, ref EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes);
Пример #47
0
 internal static void SetObjectReferenceCurveNoSync(AnimationClip clip, EditorCurveBinding binding, ObjectReferenceKeyframe[] keyframes)
 {
     Internal_SetObjectReferenceCurve(clip, binding, keyframes, false);
     Internal_InvokeOnCurveWasModified(clip, binding, keyframes != null ? CurveModifiedType.CurveModified : CurveModifiedType.CurveDeleted);
 }
Пример #48
0
 extern private static void Internal_SetEditorCurve([NotNull] AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve, bool syncEditorCurves);
Пример #49
0
 private static extern ObjectReferenceKeyframe[] INTERNAL_CALL_GetObjectReferenceCurve(AnimationClip clip, ref EditorCurveBinding binding);
Пример #50
0
 public static bool GetObjectReferenceValue(GameObject root, EditorCurveBinding binding, out UnityEngine.Object targetObject)
 {
     return(AnimationUtility.INTERNAL_CALL_GetObjectReferenceValue(root, ref binding, out targetObject));
 }
Пример #51
0
 public static ObjectReferenceKeyframe[] GetObjectReferenceCurve(AnimationClip clip, EditorCurveBinding binding)
 {
     return(AnimationUtility.INTERNAL_CALL_GetObjectReferenceCurve(clip, ref binding));
 }
Пример #52
0
 private static extern bool INTERNAL_CALL_GetObjectReferenceValue(GameObject root, ref EditorCurveBinding binding, out UnityEngine.Object targetObject);
Пример #53
0
 private static extern UnityEngine.Object INTERNAL_CALL_GetAnimatedObject(GameObject root, ref EditorCurveBinding binding);
Пример #54
0
 public static UnityEngine.Object GetAnimatedObject(GameObject root, EditorCurveBinding binding)
 {
     return(AnimationUtility.INTERNAL_CALL_GetAnimatedObject(root, ref binding));
 }
Пример #55
0
 private static extern Type INTERNAL_CALL_GetEditorCurveValueType(GameObject root, ref EditorCurveBinding binding);
Пример #56
0
 public static AnimationCurve GetEditorCurve(AnimationClip clip, EditorCurveBinding binding)
 {
     return(AnimationUtility.INTERNAL_CALL_GetEditorCurve(clip, ref binding));
 }
Пример #57
0
 internal static Type GetScriptableObjectEditorCurveValueType(ScriptableObject scriptableObject, EditorCurveBinding binding)
 {
     return(AnimationUtility.INTERNAL_CALL_GetScriptableObjectEditorCurveValueType(scriptableObject, ref binding));
 }
Пример #58
0
 private static extern Type INTERNAL_CALL_GetScriptableObjectEditorCurveValueType(ScriptableObject scriptableObject, ref EditorCurveBinding binding);
Пример #59
0
 public static bool GetFloatValue(GameObject root, string relativePath, Type type, string propertyName, out float data)
 {
     return(AnimationUtility.GetFloatValue(root, EditorCurveBinding.FloatCurve(relativePath, type, propertyName), out data));
 }
Пример #60
0
 internal static void SetEditorCurveNoSync(AnimationClip clip, EditorCurveBinding binding, AnimationCurve curve)
 {
     Internal_SetEditorCurve(clip, binding, curve, false);
     Internal_InvokeOnCurveWasModified(clip, binding, curve != null ? CurveModifiedType.CurveModified : CurveModifiedType.CurveDeleted);
 }