public override void PostUpdate(DirectorControlState state, bool inArea, EventType type)
{
CinemaActorClipCurve clipCurve = Wrapper.Behaviour as CinemaActorClipCurve;
if (clipCurve == null)
{
return;
}
hasUndoRedoBeenPerformed = (Event.current.type == EventType.ValidateCommand && Event.current.commandName == "UndoRedoPerformed");
if ((HaveCurvesChanged || hasUndoRedoBeenPerformed) && state.IsInPreviewMode)
{
clipCurve.SampleTime(state.ScrubberPosition);
HaveCurvesChanged = false;
hasUserInteracted = false;
}
else
{
if (state.IsInPreviewMode && IsEditing && GUIUtility.hotControl == 0 && (clipCurve.Firetime <= state.ScrubberPosition && state.ScrubberPosition <= clipCurve.Firetime + clipCurve.Duration) && clipCurve.Actor != null)
{
inArea = !(Event.current.shift && Event.current.keyCode == KeyCode.F && Event.current.control);
checkToAddNewKeyframes(clipCurve, state, EditorWindow.focusedWindow == DirectorWindow.Instance && inArea);
}
}
}
public void AddClipCurveDataRotation(CinemaActorClipCurve curveData, EditorCurveBinding component, bool isProperty, AnimationCurve curve, Component com)
{
MemberClipCurveData data = new MemberClipCurveData();
data.SetCurve(0, curve);
data.Type = component.type.Name;
data.PropertyName = "localEulerAngles";
data.IsProperty = isProperty;
data.PropertyType = PropertyTypeInfo.Vector3;
curveData.curveData.Add(data);
}
protected override void showContextMenu(Behaviour behaviour)
{
CinemaActorClipCurve clipCurve = behaviour as CinemaActorClipCurve;
if (clipCurve == null)
{
return;
}
List <KeyValuePair <string, string> > currentCurves = new List <KeyValuePair <string, string> >();
{
var __list1 = clipCurve.CurveData;
var __listCount1 = __list1.Count;
for (int __i1 = 0; __i1 < __listCount1; ++__i1)
{
var data = (MemberClipCurveData)__list1[__i1];
{
KeyValuePair <string, string> curveStrings = new KeyValuePair <string, string>(data.Type, data.PropertyName);
currentCurves.Add(curveStrings);
}
}
}
GenericMenu createMenu = new GenericMenu();
if (clipCurve.Actor != null)
{
Component[] components = DirectorHelper.getValidComponents(clipCurve.Actor.gameObject);
for (int i = 0; i < components.Length; i++)
{
Component component = components[i];
MemberInfo[] members = DirectorHelper.getValidMembers(component);
for (int j = 0; j < members.Length; j++)
{
AddCurveContext context = new AddCurveContext();
context.clipCurve = clipCurve;
context.component = component;
context.memberInfo = members[j];
if (!currentCurves.Contains(new KeyValuePair <string, string>(component.GetType().Name, members[j].Name)))
{
createMenu.AddItem(new GUIContent(string.Format("Add Curve/{0}/{1}", component.GetType().Name, DirectorHelper.GetUserFriendlyName(component, members[j]))), false, addCurve, context);
}
}
}
createMenu.AddSeparator(string.Empty);
}
createMenu.AddItem(new GUIContent("Copy"), false, copyItem, behaviour);
createMenu.AddSeparator(string.Empty);
createMenu.AddItem(new GUIContent("Clear"), false, deleteItem, clipCurve);
createMenu.ShowAsContext();
}
public void OnSceneGUI()
{
CinemaActorClipCurve clipCurveGameObject = (target as CinemaActorClipCurve);
foreach (MemberClipCurveData data in clipCurveGameObject.CurveData)
{
if (data.Type == "Transform" && data.PropertyName == "localPosition")
{
//Vector3 position = new Vector3(data.Curve1[0].value, data.Curve2[0].value, data.Curve3[0].value);
//Handles.DrawSphere(0, position, Quaternion.identity, 10);
}
}
}
protected void loadItem(object userData)
{
CinemaActorClipCurve behaviour = userData as CinemaActorClipCurve;
if (behaviour != null)
{
Animator animator = behaviour.Actor.GetComponent <Animator>();
if (animator == null)
{
EditorUtility.DisplayDialog("错误", "没有找到Animator组件", "确定");
return;
}
AnimatorClipInfo[] clip = animator.GetCurrentAnimatorClipInfo(0);
if (clip == null || clip.Length <= 0)
{
EditorUtility.DisplayDialog("错误", "没有找到animator资源", "确定");
return;
}
var bind = AnimationUtility.GetCurveBindings(clip[0].clip);
if (bind == null)
{
EditorUtility.DisplayDialog("错误", "没有找到bindings", "确定");
return;
}
var curve = AnimationUtility.GetEditorCurve(clip[0].clip, bind[0]);
if (curve == null)
{
EditorUtility.DisplayDialog("错误", "没有找到曲线", "确定");
return;
}
behaviour.curveData.Clear();
AddClipCurveData(behaviour, bind[0], true, curve, behaviour.Actor.transform);
var data = AnimationUtility.GetEditorCurve(clip[0].clip, bind[1]);
behaviour.curveData[0].SetCurve(1, data);
data = AnimationUtility.GetEditorCurve(clip[0].clip, bind[2]);
behaviour.curveData[0].SetCurve(2, data);
curve = AnimationUtility.GetEditorCurve(clip[0].clip, bind[3]);
AddClipCurveDataRotation(behaviour, bind[3], true, curve, behaviour.Actor.transform);
data = AnimationUtility.GetEditorCurve(clip[0].clip, bind[4]);
behaviour.curveData[1].SetCurve(1, data);
data = AnimationUtility.GetEditorCurve(clip[0].clip, bind[5]);
behaviour.curveData[1].SetCurve(2, data);
}
}
/// <summary>
/// Update and Draw the inspector
/// </summary>
public override void OnInspectorGUI()
{
curveTrack.Update();
TimelineItem[] items = (target as CurveTrack).TimelineItems;
for (int i = 0; i < items.Length; i++)
{
CinemaActorClipCurve clip = items[i] as CinemaActorClipCurve;
EditorGUILayout.ObjectField(clip.name, clip, typeof(CinemaActorClipCurve), true);
}
if (GUILayout.Button(addClip))
{
Undo.RegisterCreatedObjectUndo(CutsceneItemFactory.CreateActorClipCurve((target as CurveTrack)).gameObject, "Create Curve Clip");
}
curveTrack.ApplyModifiedProperties();
}
public void OnSceneGUI()
{
CinemaActorClipCurve clipCurveGameObject = (target as CinemaActorClipCurve);
{
var __list1 = clipCurveGameObject.CurveData;
var __listCount1 = __list1.Count;
for (int __i1 = 0; __i1 < __listCount1; ++__i1)
{
var data = (MemberClipCurveData)__list1[__i1];
{
if (data.Type == "Transform" && data.PropertyName == "localPosition")
{
//Vector3 position = new Vector3(data.Curve1[0].value, data.Curve2[0].value, data.Curve3[0].value);
//Handles.DrawSphere(0, position, Quaternion.identity, 10);
}
}
}
}
}
public override void PostUpdate(DirectorControlState state)
{
CinemaActorClipCurve clipCurve = Wrapper.Behaviour as CinemaActorClipCurve;
if (clipCurve == null)
{
return;
}
hasUndoRedoBeenPerformed = (Event.current.type == EventType.ValidateCommand && Event.current.commandName == "UndoRedoPerformed");
if ((HaveCurvesChanged || hasUndoRedoBeenPerformed) && state.IsInPreviewMode)
{
clipCurve.SampleTime(state.ScrubberPosition);
HaveCurvesChanged = false;
hasUserInteracted = false;
}
else
{
checkToAddNewKeyframes(clipCurve, state);
}
}
internal static CinemaActorClipCurve CreateActorClipCurve(CurveTrack track)
{
string name = DirectorHelper.getCutsceneItemName(track.gameObject, CURVE_CLIP_NAME_DEFAULT, typeof(CinemaActorClipCurve));
GameObject item = new GameObject(name);
item.transform.parent = track.transform;
CinemaActorClipCurve clip = item.AddComponent <CinemaActorClipCurve>();
SortedDictionary <float, CinemaActorClipCurve> sortedItems = new SortedDictionary <float, CinemaActorClipCurve>();
foreach (CinemaActorClipCurve c in track.TimelineItems)
{
sortedItems.Add(c.Firetime, c);
}
float latestTime = 0;
float length = DEFAULT_CURVE_LENGTH;
foreach (CinemaActorClipCurve c in sortedItems.Values)
{
if (latestTime >= c.Firetime)
{
latestTime = Mathf.Max(latestTime, c.Firetime + c.Duration);
}
else
{
length = c.Firetime - latestTime;
break;
}
}
clip.Firetime = latestTime;
clip.Duration = length;
return(clip);
}
private void checkToAddNewKeyframes(CinemaActorClipCurve clipCurve, DirectorControlState state, bool inArea)
{
Undo.RecordObject(clipCurve, "Auto Key Created");
bool hasDifferenceBeenFound = false;
foreach (MemberClipCurveData data in clipCurve.CurveData)
{
if (data.Type == string.Empty || data.PropertyName == string.Empty)
{
continue;
}
Component component = clipCurve.Actor.GetComponent(data.Type);
object value = CinemaActorClipCurve.GetCurrentValue(component, data.PropertyName, data.IsProperty);
PropertyTypeInfo typeInfo = data.PropertyType;
if (typeInfo == PropertyTypeInfo.Int || typeInfo == PropertyTypeInfo.Long || typeInfo == PropertyTypeInfo.Float || typeInfo == PropertyTypeInfo.Double)
{
float x = (float)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(x, curve1Value, data.Curve1, state.ScrubberPosition, inArea);
}
else if (typeInfo == PropertyTypeInfo.Vector2)
{
Vector2 vec2 = (Vector2)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec2.x, curve1Value, data.Curve1, state.ScrubberPosition, inArea);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec2.y, curve2Value, data.Curve2, state.ScrubberPosition, inArea);
}
else if (typeInfo == PropertyTypeInfo.Vector3)
{
Vector3 vec3 = (Vector3)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec3.x, curve1Value, data.Curve1, state.ScrubberPosition, inArea);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec3.y, curve2Value, data.Curve2, state.ScrubberPosition, inArea);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec3.z, curve3Value, data.Curve3, state.ScrubberPosition, inArea);
}
else if (typeInfo == PropertyTypeInfo.Vector4)
{
Vector4 vec4 = (Vector4)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
float curve4Value = data.Curve4.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.x, curve1Value, data.Curve1, state.ScrubberPosition, inArea);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.y, curve2Value, data.Curve2, state.ScrubberPosition, inArea);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.z, curve3Value, data.Curve3, state.ScrubberPosition, inArea);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.w, curve4Value, data.Curve4, state.ScrubberPosition, inArea);
}
else if (typeInfo == PropertyTypeInfo.Quaternion)
{
Quaternion quaternion = (Quaternion)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
float curve4Value = data.Curve4.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(quaternion.x, curve1Value, data.Curve1, state.ScrubberPosition, inArea, QUATERNION_THRESHOLD);
hasDifferenceBeenFound |= addKeyOnUserInteraction(quaternion.y, curve2Value, data.Curve2, state.ScrubberPosition, inArea, QUATERNION_THRESHOLD);
hasDifferenceBeenFound |= addKeyOnUserInteraction(quaternion.z, curve3Value, data.Curve3, state.ScrubberPosition, inArea, QUATERNION_THRESHOLD);
hasDifferenceBeenFound |= addKeyOnUserInteraction(quaternion.w, curve4Value, data.Curve4, state.ScrubberPosition, inArea, QUATERNION_THRESHOLD);
}
else if (typeInfo == PropertyTypeInfo.Color)
{
Color color = (Color)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
float curve4Value = data.Curve4.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.r, curve1Value, data.Curve1, state.ScrubberPosition, inArea);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.g, curve2Value, data.Curve2, state.ScrubberPosition, inArea);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.b, curve3Value, data.Curve3, state.ScrubberPosition, inArea);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.a, curve4Value, data.Curve4, state.ScrubberPosition, inArea);
}
}
if (hasDifferenceBeenFound)
{
hasUserInteracted = true;
FillReverseKeyframes();
EditorUtility.SetDirty(clipCurve);
}
else
{
m_RecordList.Clear();
}
}
private void checkToAddNewKeyframes(CinemaActorClipCurve clipCurve, DirectorControlState state)
{
if (state.IsInPreviewMode && IsEditing && GUIUtility.hotControl == 0 &&
(clipCurve.Firetime <= state.ScrubberPosition &&
state.ScrubberPosition <= clipCurve.Firetime + clipCurve.Duration) && clipCurve.Actor != null)
{
Undo.RecordObject(clipCurve, "Auto Key Created");
bool hasDifferenceBeenFound = false;
foreach (MemberClipCurveData data in clipCurve.CurveData)
{
if (data.Type == string.Empty || data.PropertyName == string.Empty)
{
continue;
}
Component component = clipCurve.Actor.GetComponent(data.Type);
object value = clipCurve.GetCurrentValue(component, data.PropertyName, data.IsProperty);
PropertyTypeInfo typeInfo = data.PropertyType;
if (typeInfo == PropertyTypeInfo.Int || typeInfo == PropertyTypeInfo.Long || typeInfo == PropertyTypeInfo.Float ||
typeInfo == PropertyTypeInfo.Double)
{
float x = (float)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(x, curve1Value, data.Curve1, state.ScrubberPosition);
}
else if (typeInfo == PropertyTypeInfo.Vector2)
{
Vector2 vec2 = (Vector2)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec2.x, curve1Value, data.Curve1, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec2.y, curve2Value, data.Curve2, state.ScrubberPosition);
}
else if (typeInfo == PropertyTypeInfo.Vector3)
{
Vector3 vec3 = (Vector3)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec3.x, curve1Value, data.Curve1, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec3.y, curve2Value, data.Curve2, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec3.z, curve3Value, data.Curve3, state.ScrubberPosition);
}
else if (typeInfo == PropertyTypeInfo.Vector4)
{
Vector4 vec4 = (Vector4)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
float curve4Value = data.Curve4.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.x, curve1Value, data.Curve1, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.y, curve2Value, data.Curve2, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.z, curve3Value, data.Curve3, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.w, curve4Value, data.Curve4, state.ScrubberPosition);
}
else if (typeInfo == PropertyTypeInfo.Quaternion)
{
Quaternion quaternion = (Quaternion)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
float curve4Value = data.Curve4.Evaluate(state.ScrubberPosition);
for (int j = 0; j < data.Curve1.length; j++)
{
Keyframe k = data.Curve1[j];
if (k.time == state.ScrubberPosition)
{
Keyframe newKeyframe = new Keyframe(k.time, quaternion.x, k.inTangent, k.outTangent);
newKeyframe.tangentMode = k.tangentMode;
AnimationCurveHelper.MoveKey(data.Curve1, j, newKeyframe);
}
}
for (int j = 0; j < data.Curve2.length; j++)
{
Keyframe k = data.Curve2[j];
if (k.time == state.ScrubberPosition)
{
Keyframe newKeyframe = new Keyframe(k.time, quaternion.y, k.inTangent, k.outTangent);
newKeyframe.tangentMode = k.tangentMode;
AnimationCurveHelper.MoveKey(data.Curve2, j, newKeyframe);
}
}
for (int j = 0; j < data.Curve3.length; j++)
{
Keyframe k = data.Curve3[j];
if (k.time == state.ScrubberPosition)
{
Keyframe newKeyframe = new Keyframe(k.time, quaternion.z, k.inTangent, k.outTangent);
newKeyframe.tangentMode = k.tangentMode;
AnimationCurveHelper.MoveKey(data.Curve3, j, newKeyframe);
}
}
for (int j = 0; j < data.Curve4.length; j++)
{
Keyframe k = data.Curve4[j];
if (k.time == state.ScrubberPosition)
{
Keyframe newKeyframe = new Keyframe(k.time, quaternion.w, k.inTangent, k.outTangent);
newKeyframe.tangentMode = k.tangentMode;
AnimationCurveHelper.MoveKey(data.Curve4, j, newKeyframe);
}
}
Quaternion curveValue = new Quaternion(curve1Value, curve2Value, curve3Value, curve4Value);
float angle = Vector3.Angle(quaternion.eulerAngles, curveValue.eulerAngles);
hasDifferenceBeenFound = hasDifferenceBeenFound || angle > QUATERNION_THRESHOLD;
if (angle > QUATERNION_THRESHOLD && hasUserInteracted)
{
data.Curve1.AddKey(state.ScrubberPosition, quaternion.x);
data.Curve2.AddKey(state.ScrubberPosition, quaternion.y);
data.Curve3.AddKey(state.ScrubberPosition, quaternion.z);
data.Curve4.AddKey(state.ScrubberPosition, quaternion.w);
hasUserInteracted = true;
}
}
else if (typeInfo == PropertyTypeInfo.Color)
{
Color color = (Color)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
float curve4Value = data.Curve4.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.r, curve1Value, data.Curve1, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.g, curve2Value, data.Curve2, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.b, curve3Value, data.Curve3, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.a, curve4Value, data.Curve4, state.ScrubberPosition);
}
}
if (hasDifferenceBeenFound)
{
hasUserInteracted = true;
EditorUtility.SetDirty(clipCurve);
}
}
}
public override void OnInspectorGUI()
{
actorClipCurve.Update();
CinemaActorClipCurve clipCurveGameObject = (target as CinemaActorClipCurve);
if (clipCurveGameObject == null || clipCurveGameObject.Actor == null)
{
EditorGUILayout.HelpBox(ERROR_MSG, UnityEditor.MessageType.Error);
return;
}
GameObject actor = clipCurveGameObject.Actor.gameObject;
List <KeyValuePair <string, string> > currentCurves = new List <KeyValuePair <string, string> >();
EditorGUILayout.PropertyField(editorRevert);
EditorGUILayout.PropertyField(runtimeRevert);
SerializedProperty curveData = actorClipCurve.FindProperty("curveData");
if (curveData.arraySize > 0)
{
isDataFolded = EditorGUILayout.Foldout(isDataFolded, dataContent);
if (isDataFolded)
{
for (int i = 0; i < curveData.arraySize; i++)
{
SerializedProperty member = curveData.GetArrayElementAtIndex(i);
SerializedProperty typeProperty = member.FindPropertyRelative("Type");
SerializedProperty memberProperty = member.FindPropertyRelative("PropertyName");
KeyValuePair <string, string> curveStrings = new KeyValuePair <string, string>(typeProperty.stringValue, memberProperty.stringValue);
currentCurves.Add(curveStrings);
Component c = actor.GetComponent(typeProperty.stringValue);
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(new GUIContent(string.Format("{0}.{1}", typeProperty.stringValue, DirectorHelper.GetUserFriendlyName(typeProperty.stringValue, memberProperty.stringValue)), EditorGUIUtility.ObjectContent(c, c.GetType()).image));
if (GUILayout.Button("-", GUILayout.Width(24f)))
{
curveData.DeleteArrayElementAtIndex(i);
}
EditorGUILayout.EndHorizontal();
}
}
GUILayout.Space(5);
}
isNewCurveFolded = EditorGUILayout.Foldout(isNewCurveFolded, addContent);
if (isNewCurveFolded)
{
List <GUIContent> componentSelectionList = new List <GUIContent>();
List <GUIContent> propertySelectionList = new List <GUIContent>();
Component[] components = DirectorHelper.getValidComponents(actor);
for (int i = 0; i < components.Length; i++)
{
Component component = components[i];
if (component != null)
{
componentSelectionList.Add(new GUIContent(component.GetType().Name));
}
}
componentSeletion = EditorGUILayout.Popup(new GUIContent("Component"), componentSeletion, componentSelectionList.ToArray());
MemberInfo[] members = DirectorHelper.getValidMembers(components[componentSeletion]);
List <MemberInfo> newMembers = new List <MemberInfo>();
for (int i = 0; i < members.Length; i++)
{
MemberInfo memberInfo = members[i];
if (!currentCurves.Contains(new KeyValuePair <string, string>(components[componentSeletion].GetType().Name, memberInfo.Name)))
{
newMembers.Add(memberInfo);
}
}
members = newMembers.ToArray();
for (int i = 0; i < members.Length; i++)
{
MemberInfo memberInfo = members[i];
string name = DirectorHelper.GetUserFriendlyName(components[componentSeletion], memberInfo);
propertySelectionList.Add(new GUIContent(name));
}
propertySelection = EditorGUILayout.Popup(new GUIContent("Property"), propertySelection, propertySelectionList.ToArray());
if (GUILayout.Button("Add Curve") && members.Length > 0)
{
Type t = null;
PropertyInfo property = members[propertySelection] as PropertyInfo;
FieldInfo field = members[propertySelection] as FieldInfo;
bool isProperty = false;
if (property != null)
{
t = property.PropertyType;
isProperty = true;
}
else if (field != null)
{
t = field.FieldType;
isProperty = false;
}
clipCurveGameObject.AddClipCurveData(components[componentSeletion], members[propertySelection].Name, isProperty, t);
}
}
actorClipCurve.ApplyModifiedProperties();
}
public void OnSceneGUI()
{
CinemaActorClipCurve clipCurveGameObject = (target as CinemaActorClipCurve);
for (int i = 0; i < clipCurveGameObject.CurveData.Count; i++)
{
MemberClipCurveData data = clipCurveGameObject.CurveData[i];
if (data.Type == "Transform" && data.PropertyName == "localPosition")
{
HandlesUtility.DrawCurvePath(data.Curve1, data.Curve2, data.Curve3);
/* for (int j = 0; j < data.Curve1.keys.Length - 1; j++)
* {
* //AnimationUtility.SetKeyLeftTangentMode(data.Curve1, j, AnimationUtility.TangentMode.Linear);
* Keyframe key1x = data.Curve1.keys[j];
* Keyframe key1y = data.Curve2.keys[j];
* Keyframe key1z = data.Curve3.keys[j];
* Keyframe key2x = data.Curve1.keys[j + 1];
* Keyframe key2y = data.Curve2.keys[j + 1];
* Keyframe key2z = data.Curve3.keys[j + 1];
*
* Vector3 position = new Vector3(key1x.value, key1y.value, key1z.value);
* Vector3 inTangent1 = new Vector3(key1x.inTangent, key1y.inTangent, key1z.inTangent);
* Vector3 outTangent1 = new Vector3(key1x.outTangent, key1y.outTangent, key1z.outTangent);
*
* Vector3 position2 = new Vector3(key2x.value, key2y.value, key2z.value);
* Vector3 inTangent2 = new Vector3(key2x.inTangent, key2y.inTangent, key2z.inTangent);
* Vector3 outTangent2 = new Vector3(key2x.outTangent, key2y.outTangent, key2z.outTangent);
*
* float handleSize = HandlesUtility.GetHandleSize(position);
* Handles.Label(position + new Vector3(0.25f * handleSize, 0.0f * handleSize, 0.0f * handleSize), j.ToString());
*
* Vector3 nPosition = HandlesUtility.PositionHandle(position, Quaternion.identity);
* if (position != nPosition)
* {
* Keyframe nkey1 = new Keyframe(data.Curve1.keys[j].time, nPosition.x);
* data.Curve1.MoveKey(j, nkey1);
* Keyframe nkey2 = new Keyframe(data.Curve2.keys[j].time, nPosition.y);
* data.Curve2.MoveKey(j, nkey2);
* Keyframe nkey3 = new Keyframe(data.Curve3.keys[j].time, nPosition.z);
* data.Curve3.MoveKey(j, nkey3);
* }
* if (j == data.Curve1.length - 2)
* {
* Vector3 nPosition2 = HandlesUtility.PositionHandle(position2, Quaternion.identity);
* float handleSize2 = HandlesUtility.GetHandleSize(position2);
* Handles.Label(position2 + new Vector3(0.25f * handleSize2, 0.0f * handleSize2, 0.0f * handleSize2), (j+1).ToString());
*
* if (position2 != nPosition2)
* {
* Keyframe nkey1 = new Keyframe(data.Curve1.keys[j+1].time, nPosition2.x);
* data.Curve1.MoveKey(j + 1, nkey1);
* Keyframe nkey2 = new Keyframe(data.Curve2.keys[j + 1].time, nPosition2.y);
* data.Curve2.MoveKey(j + 1, nkey2);
* Keyframe nkey3 = new Keyframe(data.Curve3.keys[j + 1].time, nPosition2.z);
* data.Curve3.MoveKey(j + 1, nkey3);
* }
* }
*
* Vector3 ninTangent1 = HandlesUtility.TangentHandle(inTangent1 + position);
* if (inTangent1 != ninTangent1)
* {
* Keyframe ok1= data.Curve1.keys[j];
* Keyframe nkey1 = new Keyframe(ok1.time, ok1.value, ninTangent1.x - ok1.value, ok1.outTangent);
* data.Curve1.MoveKey(j, nkey1);
* Keyframe ok2 = data.Curve2.keys[j];
* Keyframe nkey2 = new Keyframe(ok2.time, ok2.value, ninTangent1.y - ok2.value, ok2.outTangent);
* data.Curve2.MoveKey(j, nkey2);
* Keyframe ok3 = data.Curve3.keys[j];
* Keyframe nkey3 = new Keyframe(ok3.time, ok3.value, ninTangent1.z - ok3.value, ok3.outTangent);
* data.Curve3.MoveKey(j, nkey3);
* }
*
* float time1 = data.Curve1.keys[j].time;
* float time2 = data.Curve1.keys[j +1].time;
* int N = 20;
* float gap = (time2 - time1) / N;
*
* for (float t = time1; t < time2; t += gap)
* {
* Vector3 dposition = new Vector3(data.Curve1.Evaluate(t), data.Curve2.Evaluate(t), data.Curve3.Evaluate(t));
* Vector3 dposition2 = new Vector3(data.Curve1.Evaluate(t + gap), data.Curve2.Evaluate(t + gap), data.Curve3.Evaluate(t + gap));
* Handles.color = Color.red;
* Handles.DrawLine(dposition, dposition2);
* Handles.color = Color.white;
* }
*
* }*/
}
}
}
private void showInScene(object userData)
{
CinemaActorClipCurve arg = userData as CinemaActorClipCurve;
arg.showInScene = !arg.showInScene;
}
private void checkToAddNewKeyframes(CinemaActorClipCurve clipCurve, DirectorControlState state)
{
if (state.IsInPreviewMode && IsEditing &&
clipCurve.Cutscene.State == Cutscene.CutsceneState.Paused && GUIUtility.hotControl == 0 &&
(clipCurve.Firetime <= state.ScrubberPosition &&
state.ScrubberPosition <= clipCurve.Firetime + clipCurve.Duration) && clipCurve.Actor != null)
{
Undo.RecordObject(clipCurve, "Auto Key Created");
bool hasDifferenceBeenFound = false;
for (int i = 0; i < clipCurve.CurveData.Count; i++)
{
MemberClipCurveData data = clipCurve.CurveData[i];
if (data.Type == string.Empty || data.PropertyName == string.Empty)
{
continue;
}
Component component = clipCurve.Actor.GetComponent(data.Type);
object value = null;
//Specific hard-coded fix for the Rotation Curve Issue.
currentlyEditingRotation = data.PropertyName == "localEulerAngles";
#if UNITY_2017_2_OR_NEWER
if (component != null)
{
Type type = component.GetType();
if (data.IsProperty)
{
// Deal with a special case, use the new TransformUtils to get the rotation value from the editor field.
if (type == typeof(Transform) && data.PropertyName == "localEulerAngles")
{
value = UnityEditor.TransformUtils.GetInspectorRotation(component.transform); // TransformUtils added in 2017.2
}
else
{
value = clipCurve.GetCurrentValue(component, data.PropertyName, data.IsProperty);
}
}
}
#else
value = clipCurve.GetCurrentValue(component, data.PropertyName, data.IsProperty);
#endif
PropertyTypeInfo typeInfo = data.PropertyType;
if (typeInfo == PropertyTypeInfo.Int || typeInfo == PropertyTypeInfo.Long)
{
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(Convert.ToInt32(value), curve1Value, data.Curve1, state.ScrubberPosition);
}
else if (typeInfo == PropertyTypeInfo.Float || typeInfo == PropertyTypeInfo.Double)
{
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(Convert.ToSingle(value), curve1Value, data.Curve1, state.ScrubberPosition);
}
else if (typeInfo == PropertyTypeInfo.Vector2)
{
Vector2 vec2 = (Vector2)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec2.x, curve1Value, data.Curve1, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec2.y, curve2Value, data.Curve2, state.ScrubberPosition);
}
else if (typeInfo == PropertyTypeInfo.Vector3)
{
//Special check for rotations
if (!currentlyEditingRotation || (currentlyEditingRotation && clipCurve.Actor.transform.hasChanged))
{
Vector3 vec3 = (Vector3)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec3.x, curve1Value, data.Curve1, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec3.y, curve2Value, data.Curve2, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec3.z, curve3Value, data.Curve3, state.ScrubberPosition);
}
}
else if (typeInfo == PropertyTypeInfo.Vector4)
{
Vector4 vec4 = (Vector4)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
float curve4Value = data.Curve4.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.x, curve1Value, data.Curve1, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.y, curve2Value, data.Curve2, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.z, curve3Value, data.Curve3, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(vec4.w, curve4Value, data.Curve4, state.ScrubberPosition);
}
else if (typeInfo == PropertyTypeInfo.Quaternion)
{
Quaternion quaternion = (Quaternion)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
float curve4Value = data.Curve4.Evaluate(state.ScrubberPosition);
for (int j = 0; j < data.Curve1.length; j++)
{
Keyframe k = data.Curve1[j];
if (k.time == state.ScrubberPosition)
{
Keyframe newKeyframe = new Keyframe(k.time, quaternion.x, k.inTangent, k.outTangent);
newKeyframe.tangentMode = k.tangentMode;
AnimationCurveHelper.MoveKey(data.Curve1, j, newKeyframe);
}
}
for (int j = 0; j < data.Curve2.length; j++)
{
Keyframe k = data.Curve2[j];
if (k.time == state.ScrubberPosition)
{
Keyframe newKeyframe = new Keyframe(k.time, quaternion.y, k.inTangent, k.outTangent);
newKeyframe.tangentMode = k.tangentMode;
AnimationCurveHelper.MoveKey(data.Curve2, j, newKeyframe);
}
}
for (int j = 0; j < data.Curve3.length; j++)
{
Keyframe k = data.Curve3[j];
if (k.time == state.ScrubberPosition)
{
Keyframe newKeyframe = new Keyframe(k.time, quaternion.z, k.inTangent, k.outTangent);
newKeyframe.tangentMode = k.tangentMode;
AnimationCurveHelper.MoveKey(data.Curve3, j, newKeyframe);
}
}
for (int j = 0; j < data.Curve4.length; j++)
{
Keyframe k = data.Curve4[j];
if (k.time == state.ScrubberPosition)
{
Keyframe newKeyframe = new Keyframe(k.time, quaternion.w, k.inTangent, k.outTangent);
newKeyframe.tangentMode = k.tangentMode;
AnimationCurveHelper.MoveKey(data.Curve4, j, newKeyframe);
}
}
Quaternion curveValue = new Quaternion(curve1Value, curve2Value, curve3Value, curve4Value);
float angle = Vector3.Angle(quaternion.eulerAngles, curveValue.eulerAngles);
hasDifferenceBeenFound = hasDifferenceBeenFound || angle > QUATERNION_THRESHOLD;
if (angle > QUATERNION_THRESHOLD && hasUserInteracted)
{
data.Curve1.AddKey(state.ScrubberPosition, quaternion.x);
data.Curve2.AddKey(state.ScrubberPosition, quaternion.y);
data.Curve3.AddKey(state.ScrubberPosition, quaternion.z);
data.Curve4.AddKey(state.ScrubberPosition, quaternion.w);
hasUserInteracted = true;
}
}
else if (typeInfo == PropertyTypeInfo.Color)
{
Color color = (Color)value;
float curve1Value = data.Curve1.Evaluate(state.ScrubberPosition);
float curve2Value = data.Curve2.Evaluate(state.ScrubberPosition);
float curve3Value = data.Curve3.Evaluate(state.ScrubberPosition);
float curve4Value = data.Curve4.Evaluate(state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.r, curve1Value, data.Curve1, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.g, curve2Value, data.Curve2, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.b, curve3Value, data.Curve3, state.ScrubberPosition);
hasDifferenceBeenFound |= addKeyOnUserInteraction(color.a, curve4Value, data.Curve4, state.ScrubberPosition);
}
}
if (hasDifferenceBeenFound)
{
hasUserInteracted = true;
EditorUtility.SetDirty(clipCurve);
}
}
}
