using UnityEngine;
using UnityEngine.UI;
using DG.Tweening;
using System.Collections.Generic;
using System.Collections;
#if UNITY_EDITOR
using UnityEditor;
[CustomEditor(typeof(EffectControlHelper))]
public class EffectControlHelperEditor : Editor
{
static Keyframe k0 = new Keyframe(0, 0, 1, 1);
static Keyframe k1 = new Keyframe(1, 1, 1, 1);
EffectControlHelper helper;
SerializedProperty tweenProperties;
GUIContent content = new GUIContent();
int gridID = 0;
AnimationCurve copyCurve;
Gradient copyGradient;
private void OnEnable()
{
helper = target as EffectControlHelper;
tweenProperties = serializedObject.FindProperty("tweens");
Undo.undoRedoPerformed += OnUndoRedo;
Resort();
}
private void Resort()
{
int sequenceID = 0;
for (int i = 0; i < tweenProperties.arraySize; i++)
{
var tween = tweenProperties.GetArrayElementAtIndex(i);
SerializedProperty controlType = tween.FindPropertyRelative("controlType");
if ((EffectControlHelper.ControlType)controlType.enumValueIndex ==
EffectControlHelper.ControlType.SequenceTex)
{
tween.FindPropertyRelative("key").intValue = sequenceID++;
}
}
}
void OnUndoRedo()
{
serializedObject.Update();
Repaint();
}
void OnDisable()
{
Undo.undoRedoPerformed -= OnUndoRedo;
}
public override void OnInspectorGUI()
{
serializedObject.Update();
AddTween();
SetProperty("总延迟", serializedObject.FindProperty("delay"));
RepeatSetting();
Resort();
gridID = GUILayout.SelectionGrid(gridID, GetTweenNames(), 2);
if (gridID >= 0 && gridID < helper.tweens.Count)
{
EditorGUILayout.BeginVertical("helpbox");
{
ShowListControl(ref gridID);
if (gridID >= 0 && gridID < helper.tweens.Count)
ShowAndSetTween(gridID);
}
EditorGUILayout.EndVertical();
}
if (GUILayout.Button("测试播放"))
{
if (!Application.isPlaying)
{
EditorApplication.isPlaying = true;
}
else
{
helper.RePlay();
}
}
SampleAnimation();
}
void AddTween()
{
SetField((v) =>
{
tweenProperties.GetArrayElementAtIndex(++tweenProperties.arraySize - 1).FindPropertyRelative("body").objectReferenceValue = v;
InitTween(tweenProperties.arraySize - 1, 0);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
gridID = tweenProperties.arraySize - 1;
}, () => EditorGUILayout.ObjectField("拖入需要控制的变换节点", null, typeof(Transform), true), "Set Controller");
SetField((v) =>
{
tweenProperties.GetArrayElementAtIndex(++tweenProperties.arraySize - 1).FindPropertyRelative("body").objectReferenceValue = v;
InitTween(tweenProperties.arraySize - 1, 3);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
gridID = tweenProperties.arraySize - 1;
}, () => EditorGUILayout.ObjectField("拖入需要控制的材质节点", null, typeof(Renderer), true), "Set Controller");
SetField((v) =>
{
tweenProperties.GetArrayElementAtIndex(++tweenProperties.arraySize - 1).FindPropertyRelative("body").objectReferenceValue = v;
InitTween(tweenProperties.arraySize - 1, 3);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
gridID = tweenProperties.arraySize - 1;
}, () => EditorGUILayout.ObjectField("拖入需要控制的UI网格节点", null, typeof(UIMeshRenderer), true), "Set Controller");
SetField((v) =>
{
tweenProperties.GetArrayElementAtIndex(++tweenProperties.arraySize - 1).FindPropertyRelative("body").objectReferenceValue = v;
InitTween(tweenProperties.arraySize - 1, 3);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
gridID = tweenProperties.arraySize - 1;
}, () => EditorGUILayout.ObjectField("拖入需要控制的图形节点", null, typeof(MaskableGraphic), true), "Set Controller");
SetField((v) =>
{
tweenProperties.GetArrayElementAtIndex(++tweenProperties.arraySize - 1).FindPropertyRelative("body").objectReferenceValue = v;
InitTween(tweenProperties.arraySize - 1, 5);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
gridID = tweenProperties.arraySize - 1;
}, () => EditorGUILayout.ObjectField("拖入需要控制显示的节点", null, typeof(GameObject), true), "Set Controller");
SetField((v) =>
{
tweenProperties.GetArrayElementAtIndex(++tweenProperties.arraySize - 1).FindPropertyRelative("body").objectReferenceValue = v;
InitTween(tweenProperties.arraySize - 1, 8);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
gridID = tweenProperties.arraySize - 1;
}, () => EditorGUILayout.ObjectField("拖入需要控制的投影节点", null, typeof(ProjectorPlane), true), "Set Controller");
}
void RepeatSetting()
{
#region 简易复生
SerializedProperty repeatTimes = serializedObject.FindProperty("repeatTimes");
SetField((v) =>
{
repeatTimes.arraySize = Mathf.Max(0, v);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () => EditorGUILayout.DelayedIntField("简易重复", repeatTimes.arraySize), "Set Count");
if (repeatTimes.arraySize > 0)
{
EditorGUILayout.BeginVertical("helpBox");
{
for (int i = 0; i < repeatTimes.arraySize; i++)
{
SetField((v) =>
{
repeatTimes.GetArrayElementAtIndex(i).floatValue = Mathf.Max(0, v);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () => EditorGUILayout.FloatField(string.Format(" 延迟[{0}]", i), repeatTimes.GetArrayElementAtIndex(i).floatValue), "Set Time");
}
if (repeatTimes.arraySize > 0)
{
SetProperty("依次偏移", serializedObject.FindProperty("offset"));
SetProperty("依次偏转", serializedObject.FindProperty("angleOff"));
SetProperty("依次缩放", serializedObject.FindProperty("scale"));
SetProperty("存在时间", serializedObject.FindProperty("instanceExistTime"));
}
}
EditorGUILayout.EndVertical();
}
#endregion
#region 自定义复生
SerializedProperty avatars = serializedObject.FindProperty("avatars");
SerializedProperty avatar;
SetField((v) =>
{
int oldSize = avatars.arraySize;
avatars.arraySize = Mathf.Max(0, v);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
for (int i = oldSize; i < avatars.arraySize; i++)
{
avatar = avatars.GetArrayElementAtIndex(i);
avatar.FindPropertyRelative("scale").vector3Value = Vector3.one;
avatar.FindPropertyRelative("duration").floatValue = 1;
}
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () => EditorGUILayout.DelayedIntField("自定义重复", avatars.arraySize), "Set Count");
for (int i = 0; i < avatars.arraySize; i++)
{
avatar = avatars.GetArrayElementAtIndex(i);
EditorGUILayout.BeginVertical("helpbox");
{
SetProperty("延迟", avatar.FindPropertyRelative("delay"));
SetProperty("位置", avatar.FindPropertyRelative("position"));
SetProperty("角度", avatar.FindPropertyRelative("rotation"));
SetProperty("比例", avatar.FindPropertyRelative("scale"));
SetProperty("存在时间", avatar.FindPropertyRelative("duration"));
}
EditorGUILayout.EndVertical();
}
#endregion
}
void ShowListControl(ref int i)
{
EditorGUILayout.BeginHorizontal();
{
EffectControlHelper.TweenGroup tween = helper.tweens[i];
SetField((v) => tween.body = v, () => EditorGUILayout.ObjectField(tween.body, tween.body.GetType(), true), "Change Body");
if (GUILayout.Button("复制", GUILayout.Width(40)))
{
if (i >= 0)
{
Undo.RecordObject(helper, "Copy");
EffectControlHelper.TweenGroup clone = new EffectControlHelper.TweenGroup(helper.tweens[i]);
helper.tweens.Add(clone);
EditorUtility.SetDirty(helper);
serializedObject.Update();
}
}
if (GUILayout.Button("上移", GUILayout.Width(40)))
{
if (i > 0)
{
Undo.RecordObject(helper, "Move Up");
tweenProperties.MoveArrayElement(i, i - 1);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
EditorUtility.SetDirty(helper);
}
}
if (GUILayout.Button("下移", GUILayout.Width(40)))
{
if (i < tweenProperties.arraySize - 1)
{
Undo.RecordObject(helper, "Move Down");
tweenProperties.MoveArrayElement(i, i + 1);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
EditorUtility.SetDirty(helper);
}
}
if (GUILayout.Button("删除", GUILayout.Width(40)))
{
Undo.RecordObject(helper, "Remove");
tweenProperties.DeleteArrayElementAtIndex(i--);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
EditorUtility.SetDirty(helper);
}
}
EditorGUILayout.EndHorizontal();
}
void ShowAndSetTween(int i)
{
SerializedProperty tween = tweenProperties.GetArrayElementAtIndex(i);
SerializedProperty controlType = tween.FindPropertyRelative("controlType");
SetField((v) =>
{
if (helper.tweens[i].body is Renderer || helper.tweens[i].body is UIMeshRenderer || helper.tweens[i].body is MaskableGraphic)
{
if (v != EffectControlHelper.ControlType.TintColor
&& v != EffectControlHelper.ControlType.UV
&& v != EffectControlHelper.ControlType.ShaderValue
&& v != EffectControlHelper.ControlType.SequenceTex)
v = EffectControlHelper.ControlType.TintColor;
}
else if (helper.tweens[i].body is Transform)
{
if (v != EffectControlHelper.ControlType.Position
&& v != EffectControlHelper.ControlType.Rotation
&& v != EffectControlHelper.ControlType.Scale)
v = EffectControlHelper.ControlType.Position;
}
else if (helper.tweens[i].body is GameObject)
v = EffectControlHelper.ControlType.Visible;
else if (helper.tweens[i].body is ProjectorPlane)
v = EffectControlHelper.ControlType.ProjectorPlane;
controlType.intValue = (int)v;
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () =>
(EffectControlHelper.ControlType)EditorGUILayout.EnumPopup("控制方式", (EffectControlHelper.ControlType)controlType.enumValueIndex), "Set ControlType");
switch ((EffectControlHelper.ControlType)controlType.enumValueIndex)
{
case EffectControlHelper.ControlType.Visible:
{
#region 显示
SetProperty("延迟(不再使用)", tween.FindPropertyRelative("delay"));
SetProperty("可见(不再使用)", tween.FindPropertyRelative("visible"));
SerializedProperty visibles = tween.FindPropertyRelative("visibles");
SetField((v) =>
{
visibles.arraySize = Mathf.Max(0, v);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () => EditorGUILayout.IntField("可视组", visibles.arraySize), "Set Size");
for (int s = 0; s < visibles.arraySize; s++)
{
EditorGUILayout.BeginHorizontal();
{
SerializedProperty visible = visibles.GetArrayElementAtIndex(s);
SetField((v) =>
{
visible.FindPropertyRelative("delay").floatValue = Mathf.Max(0, v);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () => EditorGUILayout.DelayedFloatField("时间", visible.FindPropertyRelative("delay").floatValue), "Set Delay");
SetField((v) =>
{
visible.FindPropertyRelative("visible").boolValue = v;
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () => EditorGUILayout.ToggleLeft("可见", visible.FindPropertyRelative("visible").boolValue, GUILayout.Width(60)), "Set Visible");
}
EditorGUILayout.EndHorizontal();
}
#endregion
break;
}
case EffectControlHelper.ControlType.Position:
case EffectControlHelper.ControlType.Rotation:
case EffectControlHelper.ControlType.Scale:
{
#region 变换动画
SetProperty("延迟", tween.FindPropertyRelative("delay"));
SetProperty("持续时间", tween.FindPropertyRelative("duration"));
SetProperty("循环(-1=无限循环)", tween.FindPropertyRelative("loop"));
SetProperty("循环方式", tween.FindPropertyRelative("loopType"));
SerializedProperty vectorCtrl = tween.FindPropertyRelative("vectorCtrl");
SetProperty("开始于", vectorCtrl.FindPropertyRelative("from"));
SetProperty("结束于", vectorCtrl.FindPropertyRelative("to"));
SetProperty("使用绝对旋转方式", tween.FindPropertyRelative("useWorldRot"));
SetProperty("使用缓动代替曲线", tween.FindPropertyRelative("useEase"));
if (tween.FindPropertyRelative("useEase").boolValue)
SetProperty("缓动类型", tween.FindPropertyRelative("ease"));
else
{
SerializedProperty curves = tween.FindPropertyRelative("curves");
if (curves.arraySize < 3)
{
int oldSize = curves.arraySize;
curves.arraySize = 3;
for (int c = oldSize; c < curves.arraySize; c++)
curves.GetArrayElementAtIndex(c).animationCurveValue = new AnimationCurve(k0, k1);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
EditorUtility.SetDirty(helper);
}
SetCurve("X曲线", curves.GetArrayElementAtIndex(0));
SetCurve("Y曲线", curves.GetArrayElementAtIndex(1));
SetCurve("Z曲线", curves.GetArrayElementAtIndex(2));
}
#endregion
break;
}
case EffectControlHelper.ControlType.TintColor:
{
#region 颜色动画
SetProperty("延迟", tween.FindPropertyRelative("delay"));
SetProperty("持续时间", tween.FindPropertyRelative("duration"));
SetProperty("循环(-1=无限循环)", tween.FindPropertyRelative("loop"));
SetProperty("循环方式", tween.FindPropertyRelative("loopType"));
SerializedProperty colorCtrl = tween.FindPropertyRelative("colorCtrl");
if (tween.FindPropertyRelative("body").objectReferenceValue is Renderer)
{
Renderer renderer = tween.FindPropertyRelative("body").objectReferenceValue as Renderer;
SelectProperty("颜色属性名", colorCtrl.FindPropertyRelative("colorName"),
GetShaderProperties(renderer.sharedMaterial, ShaderUtil.ShaderPropertyType.Color));
}
SetGradient("颜色变化", helper.tweens[i].colorCtrl.gradient, colorCtrl.FindPropertyRelative("gradient"));
#endregion
break;
}
case EffectControlHelper.ControlType.UV:
{
#region UV动画
SetProperty("延迟", tween.FindPropertyRelative("delay"));
SetProperty("持续时间", tween.FindPropertyRelative("duration"));
SetProperty("循环(-1=无限循环)", tween.FindPropertyRelative("loop"));
SetProperty("循环方式", tween.FindPropertyRelative("loopType"));
SerializedProperty uvCtrl = tween.FindPropertyRelative("uvCtrl");
if (tween.FindPropertyRelative("body").objectReferenceValue is Renderer)
{
Renderer renderer = tween.FindPropertyRelative("body").objectReferenceValue as Renderer;
if (renderer.sharedMaterial)
SelectProperty("UV属性名", uvCtrl.FindPropertyRelative("propertyName"),
GetShaderProperties(renderer.sharedMaterial, ShaderUtil.ShaderPropertyType.Vector, ShaderUtil.ShaderPropertyType.TexEnv));
}
else if (tween.FindPropertyRelative("body").objectReferenceValue is UIMeshRenderer)
{
UIMeshRenderer renderer = tween.FindPropertyRelative("body").objectReferenceValue as UIMeshRenderer;
if (renderer.material)
SelectProperty("UV属性名", uvCtrl.FindPropertyRelative("propertyName"),
GetShaderProperties(renderer.material, ShaderUtil.ShaderPropertyType.Vector, ShaderUtil.ShaderPropertyType.TexEnv));
}
else if (tween.FindPropertyRelative("body").objectReferenceValue is MaskableGraphic)
{
MaskableGraphic renderer = tween.FindPropertyRelative("body").objectReferenceValue as MaskableGraphic;
if (renderer.material)
SelectProperty("UV属性名", uvCtrl.FindPropertyRelative("propertyName"),
GetShaderProperties(renderer.material, ShaderUtil.ShaderPropertyType.Vector));
}
SerializedProperty uvInfoFrom = uvCtrl.FindPropertyRelative("from");
SerializedProperty uvInfoTo = uvCtrl.FindPropertyRelative("to");
SetField((v) =>
{
uvInfoFrom.vector4Value = new Vector4(v.x, v.y, uvInfoFrom.vector4Value.z, uvInfoFrom.vector4Value.w);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () => EditorGUILayout.Vector2Field("Tiling From", new Vector2(uvInfoFrom.vector4Value.x, uvInfoFrom.vector4Value.y)), "Set UV Tiling");
SetField((v) =>
{
uvInfoTo.vector4Value = new Vector4(v.x, v.y, uvInfoTo.vector4Value.z, uvInfoTo.vector4Value.w);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () => EditorGUILayout.Vector2Field("Tiling To", new Vector2(uvInfoTo.vector4Value.x, uvInfoTo.vector4Value.y)), "Set UV Tiling");
SetField((v) =>
{
uvInfoFrom.vector4Value = new Vector4(uvInfoFrom.vector4Value.x, uvInfoFrom.vector4Value.y, v.x, v.y);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () => EditorGUILayout.Vector2Field("Offset From", new Vector2(uvInfoFrom.vector4Value.z, uvInfoFrom.vector4Value.w)), "Set UV Offset");
SetField((v) =>
{
uvInfoTo.vector4Value = new Vector4(uvInfoTo.vector4Value.x, uvInfoTo.vector4Value.y, v.x, v.y);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () => EditorGUILayout.Vector2Field("Offset To", new Vector2(uvInfoTo.vector4Value.z, uvInfoTo.vector4Value.w)), "Set UV Offset");
SetProperty("使用缓动代替曲线", tween.FindPropertyRelative("useEase"));
if (tween.FindPropertyRelative("useEase").boolValue)
SetProperty("缓动类型", tween.FindPropertyRelative("ease"));
else
{
SerializedProperty curves = tween.FindPropertyRelative("curves");
if (curves.arraySize < 4)
{
int oldSize = curves.arraySize;
curves.arraySize = 4;
for (int c = oldSize; c < curves.arraySize; c++)
curves.GetArrayElementAtIndex(c).animationCurveValue = new AnimationCurve(k0, k1);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
EditorUtility.SetDirty(helper);
}
SetCurve("U Tiling Curve", curves.GetArrayElementAtIndex(0));
SetCurve("V Tiling Curve", curves.GetArrayElementAtIndex(1));
SetCurve("U Offset Curve", curves.GetArrayElementAtIndex(2));
SetCurve("V Offset Curve", curves.GetArrayElementAtIndex(3));
}
#endregion
break;
}
case EffectControlHelper.ControlType.SequenceTex:
{
#region 序列动画
SetProperty("延迟", tween.FindPropertyRelative("delay"));
SetProperty("持续时间", tween.FindPropertyRelative("duration"));
SetProperty("循环(-1=无限循环)", tween.FindPropertyRelative("loop"));
SetProperty("key值(不可有重复，从0开始的整数)", tween.FindPropertyRelative("key"));
SerializedProperty uvCtrl = tween.FindPropertyRelative("uvCtrl");
if (tween.FindPropertyRelative("body").objectReferenceValue is Renderer)
{
Renderer renderer = tween.FindPropertyRelative("body").objectReferenceValue as Renderer;
if (renderer.sharedMaterial)
SelectProperty("序列纹理属性名", uvCtrl.FindPropertyRelative("propertyName"),
GetShaderProperties(renderer.sharedMaterial, ShaderUtil.ShaderPropertyType.TexEnv));
}
else if (tween.FindPropertyRelative("body").objectReferenceValue is UIMeshRenderer)
{
UIMeshRenderer renderer = tween.FindPropertyRelative("body").objectReferenceValue as UIMeshRenderer;
if (renderer.material)
SelectProperty("序列纹理UV", uvCtrl.FindPropertyRelative("propertyName"),
GetShaderProperties(renderer.material, ShaderUtil.ShaderPropertyType.Vector));
}
else if (tween.FindPropertyRelative("body").objectReferenceValue is MaskableGraphic)
{
MaskableGraphic renderer = tween.FindPropertyRelative("body").objectReferenceValue as MaskableGraphic;
if (renderer.material)
SelectProperty("序列纹理UV", uvCtrl.FindPropertyRelative("propertyName"),
GetShaderProperties(renderer.material, ShaderUtil.ShaderPropertyType.Vector));
}
SerializedProperty uvInfoFrom = uvCtrl.FindPropertyRelative("from");
SerializedProperty uvInfoTo = uvCtrl.FindPropertyRelative("to");
//X,Y = 列数，行数
SetField((v) =>
{
v.x = v.x == 0 ? v.x = 1 : v.x;
v.y = v.y == 0 ? v.y = 1 : v.y;
uvInfoFrom.vector4Value = new Vector4(1 / v.x, 1 / v.y, 0, 1 - 1 / v.y);
uvInfoTo.vector4Value = new Vector4(1 / v.x, 1 / v.y, 1 - 1 / v.x, 0);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () =>
{
int xCount = (int)(1 / uvInfoFrom.vector4Value.x + 0.5f);
int yCount = (int)(1 / uvInfoFrom.vector4Value.y + 0.5f);
return EditorGUILayout.Vector2Field("U Count | V Count", new Vector2(xCount, yCount));
}, "Set Col And Row");
#endregion
break;
}
case EffectControlHelper.ControlType.ShaderValue:
{
#region 值变化
SetProperty("延迟", tween.FindPropertyRelative("delay"));
SetProperty("持续时间", tween.FindPropertyRelative("duration"));
SetProperty("循环(-1=无限循环)", tween.FindPropertyRelative("loop"));
SetProperty("循环方式", tween.FindPropertyRelative("loopType"));
SerializedProperty floatCtrol = tween.FindPropertyRelative("floatCtrl");
if (tween.FindPropertyRelative("body").objectReferenceValue is Renderer)
{
Renderer renderer = tween.FindPropertyRelative("body").objectReferenceValue as Renderer;
if (renderer.sharedMaterial)
SelectProperty("值属性名", floatCtrol.FindPropertyRelative("propertyName"),
GetShaderProperties(renderer.sharedMaterial, ShaderUtil.ShaderPropertyType.Float, ShaderUtil.ShaderPropertyType.Range));
}
else if (tween.FindPropertyRelative("body").objectReferenceValue is UIMeshRenderer)
{
UIMeshRenderer renderer = tween.FindPropertyRelative("body").objectReferenceValue as UIMeshRenderer;
if (renderer.material)
SelectProperty("值属性名", floatCtrol.FindPropertyRelative("propertyName"),
GetShaderProperties(renderer.material, ShaderUtil.ShaderPropertyType.Float, ShaderUtil.ShaderPropertyType.Range));
}
else if(tween.FindPropertyRelative("body").objectReferenceValue is MaskableGraphic)
{
MaskableGraphic renderer = tween.FindPropertyRelative("body").objectReferenceValue as MaskableGraphic;
if (renderer.material)
SelectProperty("值属性名", floatCtrol.FindPropertyRelative("propertyName"),
GetShaderProperties(renderer.material, ShaderUtil.ShaderPropertyType.Float, ShaderUtil.ShaderPropertyType.Range));
}
SetProperty("开始于", floatCtrol.FindPropertyRelative("from"));
SetProperty("结束于", floatCtrol.FindPropertyRelative("to"));
SetProperty("使用缓动代替曲线", tween.FindPropertyRelative("useEase"));
if (tween.FindPropertyRelative("useEase").boolValue)
SetProperty("缓动类型", tween.FindPropertyRelative("ease"));
else
{
SerializedProperty curves = tween.FindPropertyRelative("curves");
if (curves.arraySize < 1)
{
curves.arraySize = 1;
curves.GetArrayElementAtIndex(0).animationCurveValue = new AnimationCurve(k0, k1);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
EditorUtility.SetDirty(helper);
}
SetCurve("曲线", curves.GetArrayElementAtIndex(0));
}
#endregion
break;
}
case EffectControlHelper.ControlType.ProjectorPlane:
{
#region 投影面
SetProperty("延迟", tween.FindPropertyRelative("delay"));
SetProperty("持续时间", tween.FindPropertyRelative("duration"));
EditorGUILayout.LabelField("", "持续时间为0时，仅创建不更新，为-1时，每帧更新直到本体消亡，大于0时保持每帧更新", "Helpbox");
#endregion
break;
}
}
}
void InitTween(int i, int controlType)
{
SerializedProperty tween = tweenProperties.GetArrayElementAtIndex(tweenProperties.arraySize - 1);
tween.FindPropertyRelative("controlType").intValue = controlType;
tween.FindPropertyRelative("duration").floatValue = 1f;
tween.FindPropertyRelative("loop").intValue = 1;
SerializedProperty colorCtrl = tween.FindPropertyRelative("colorCtrl");
colorCtrl.FindPropertyRelative("colorName").stringValue = "_TintColor";
SerializedProperty unCtrl = tween.FindPropertyRelative("uvCtrl");
unCtrl.FindPropertyRelative("propertyName").stringValue = "_UV";
unCtrl.FindPropertyRelative("from").vector4Value = new Vector4(1, 1, 0, 0);
unCtrl.FindPropertyRelative("to").vector4Value = new Vector4(1, 1, 0, 0);
SerializedProperty curves = tween.FindPropertyRelative("curves");
switch (controlType)
{
case 0:
case 1:
case 2:
{
curves.arraySize = 3;
for (int c = 0; c < 3; c++)
curves.GetArrayElementAtIndex(c).animationCurveValue = new AnimationCurve(k0, k1);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}
break;
case 3:
{
serializedObject.ApplyModifiedPropertiesWithoutUndo();
helper.tweens[i].colorCtrl.gradient = new Gradient();
helper.tweens[i].colorCtrl.gradient.SetKeys(
new GradientColorKey[2] { new GradientColorKey(Color.white, 0), new GradientColorKey(Color.white, 1) },
new GradientAlphaKey[2] { new GradientAlphaKey(1, 0), new GradientAlphaKey(1, 1) });
EditorUtility.SetDirty(helper);
serializedObject.Update();
}
break;
case 4:
{
curves.arraySize = 4;
for (int c = 0; c < 4; c++)
curves.GetArrayElementAtIndex(c).animationCurveValue = new AnimationCurve(k0, k1);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}
break;
}
}
List<string> GetShaderProperties(Material material, params ShaderUtil.ShaderPropertyType[] type)
{
Shader shader = material.shader;
List<string> properties = new List<string>();
int count = ShaderUtil.GetPropertyCount(shader);
for (int i = 0; i < count; i++)
{
ShaderUtil.ShaderPropertyType propertyType = ShaderUtil.GetPropertyType(shader, i);
for (int j = 0; j < type.Length; j++)
if (propertyType == type[j])
properties.Add(ShaderUtil.GetPropertyName(shader, i));
}
return properties;
}
string[] GetTweenNames()
{
List<string> names = new List<string>();
for (int i = 0; i < helper.tweens.Count; i++)
{
if (!helper.tweens[i].body)
{
helper.tweens.RemoveAt(i--);
EditorUtility.SetDirty(helper);
serializedObject.Update();
continue;
}
names.Add(string.Format("{0}<{1}>", helper.tweens[i].body.name, helper.tweens[i].controlType.ToString()));
}
return names.ToArray();
}
void SetField<T>(System.Action<T> value, System.Func<T> func, string undoTip = null)
{
EditorGUI.BeginChangeCheck();
T result = func();
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(helper, undoTip == null ? "Field Change" : undoTip);
value(result);
EditorUtility.SetDirty(helper);
}
}
void SetProperty(string label, SerializedProperty property, string undoTip = null)
{
EditorGUI.BeginChangeCheck();
content.text = label == null ? "" : label;
EditorGUILayout.PropertyField(property, content, true);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(helper, undoTip == null ? "Property Change" : undoTip);
serializedObject.ApplyModifiedPropertiesWithoutUndo();
EditorUtility.SetDirty(helper);
}
}
void SelectProperty(string label, SerializedProperty nameProperty, List<string> filterProperties)
{
EditorGUILayout.BeginHorizontal();
{
SetProperty(label, nameProperty);
SetField((v) =>
{
nameProperty.stringValue = v;
serializedObject.ApplyModifiedPropertiesWithoutUndo();
}, () =>
{
int d = filterProperties.FindIndex(n => n.Equals(nameProperty.stringValue));
int p = EditorGUILayout.Popup(d, filterProperties.ToArray(), GUILayout.Width(80));
if (p != d) return filterProperties[p];
return nameProperty.stringValue;
});
}
EditorGUILayout.EndHorizontal();
}
void SetCurve(string label, SerializedProperty curve)
{
EditorGUILayout.BeginHorizontal();
{
SetProperty(label, curve);
GUI.color = copyCurve == null ? Color.white : Color.yellow;
if (GUILayout.Button(copyCurve == null ? "复制曲线" : "粘贴曲线", GUILayout.Width(54)))
{
if (copyCurve == null)
{
copyCurve = curve.animationCurveValue;
}
else
{
curve.animationCurveValue = new AnimationCurve(copyCurve.keys);
copyCurve = null;
serializedObject.ApplyModifiedProperties();
EditorUtility.SetDirty(helper);
}
}
GUI.color = Color.white;
}
EditorGUILayout.EndHorizontal();
}
void SetGradient(string label, Gradient gradient, SerializedProperty gradProperty)
{
EditorGUILayout.BeginHorizontal();
{
SetProperty(label, gradProperty);
GUI.color = copyGradient == null ? Color.white : Color.yellow;
if (GUILayout.Button(copyGradient != null ? "粘贴" : "复制", GUILayout.Width(54)))
{
if (copyGradient == null)
{
copyGradient = new Gradient();
copyGradient.SetKeys(gradient.colorKeys, gradient.alphaKeys);
}
else
{
Undo.RecordObject(helper, "Copy");
gradient.SetKeys(copyGradient.colorKeys, copyGradient.alphaKeys);
EditorUtility.SetDirty(helper);
serializedObject.Update();
copyGradient = null;
Repaint();
}
}
GUI.color = Color.white;
}
EditorGUILayout.EndHorizontal();
}
void SampleAnimation()
{
if (string.IsNullOrEmpty(helper.animationPath))
{
string relativePath = AssetDatabase.GetAssetPath(PrefabUtility.GetPrefabParent(helper));
helper.animationPath = string.IsNullOrEmpty(relativePath) ? helper.animationPath : relativePath.Split('.')[0];
}
SetField((v) => helper.animationPath = v, () => EditorGUILayout.DelayedTextField("采样动画路径", helper.animationPath), "Set Bake Path");
if (GUILayout.Button("采样到动画"))
{
if (!Application.isPlaying)
return;
string relativePath = helper.animationPath;
if (System.IO.Directory.Exists(relativePath.Substring(0, relativePath.LastIndexOf('/'))))
helper.BakeToClip((c) =>
{
AnimationClip clip;
if (clip = (AnimationClip)AssetDatabase.LoadAssetAtPath(relativePath + ".anim", typeof(AnimationClip)))
{
EditorUtility.CopySerialized(c, clip);
EditorUtility.SetDirty(clip);
}
else
AssetDatabase.CreateAsset(c, relativePath + ".anim");
});
}
}
}
#endif
public class EffectControlHelper : MonoBehaviour
{
public Vector3 worldRot = Vector3.zero;
public enum ControlType
{
Position = 0,
Rotation = 1,
Scale = 2,
TintColor = 3,
UV = 4,
Visible = 5,
ShaderValue = 6,
SequenceTex = 7,
ProjectorPlane = 8
}
[System.Serializable]
public class TweenGroup
{
public Object body;
public ControlType controlType;
public float delay;
public float duration;
public int loop;
public int key;
public LoopType loopType;
public Vector3Control vectorCtrl;
public ColorControl colorCtrl;
public UVControl uvCtrl;
public FloatControl floatCtrl;
public bool useEase;
public bool useWorldRot;
public Vector3 worldRot = Vector3.zero;
public AnimationCurve[] curves;
public Ease ease;
public bool visible;
public VisableGroup[] visibles;
public TweenGroup() { }
public TweenGroup(TweenGroup source)
{
body = source.body;
controlType = source.controlType;
delay = source.delay;
duration = source.duration;
loop = source.loop;
key = source.key;
loopType = source.loopType;
vectorCtrl = new Vector3Control();
vectorCtrl.from = source.vectorCtrl.from;
vectorCtrl.to = source.vectorCtrl.to;
colorCtrl = new ColorControl();
colorCtrl.colorName = source.colorCtrl.colorName;
colorCtrl.gradient = new Gradient();
colorCtrl.gradient.SetKeys(source.colorCtrl.gradient.colorKeys, source.colorCtrl.gradient.alphaKeys);
uvCtrl = new UVControl();
uvCtrl.propertyName = source.uvCtrl.propertyName;
uvCtrl.from = source.uvCtrl.from;
uvCtrl.to = source.uvCtrl.to;
floatCtrl = new FloatControl();
floatCtrl.propertyName = source.floatCtrl.propertyName;
floatCtrl.from = source.floatCtrl.from;
floatCtrl.to = source.floatCtrl.to;
useEase = source.useEase;
curves = new AnimationCurve[source.curves.Length];
for (int i = 0; i < curves.Length; i++)
curves[i] = new AnimationCurve(source.curves[i].keys);
ease = source.ease;
visible = source.visible;
}
public TweenGroup(Object body)
{
this.body = body;
if (body is Transform)
controlType = ControlType.Position;
else if (body is Renderer || body is MaskableGraphic || body is UIMeshRenderer)
controlType = ControlType.TintColor;
else
controlType = ControlType.Visible;
}
public void SetValue(float t)
{
if (body is Transform)
{
Vector3 v;
Evalute(out v, t);
switch (controlType)
{
case ControlType.Position:
(body as Transform).localPosition = v;
break;
case ControlType.Rotation:
if (useWorldRot)
(body as Transform).eulerAngles = v + worldRot;
else
(body as Transform).localEulerAngles = v;
break;
case ControlType.Scale:
(body as Transform).localScale = v;
break;
}
}
else if (body is Renderer)
{
Renderer r = body as Renderer;
if (r.material)
{
switch (controlType)
{
case ControlType.TintColor:
if (colorCtrl.gradient != null)
r.material.SetColor(colorCtrl.colorName, colorCtrl.gradient.Evaluate(t));
break;
case ControlType.UV:
{
Vector4 v;
Evalute(out v, t);
r.material.SetVector(uvCtrl.propertyName, v);
}
break;
case ControlType.ShaderValue:
{
float v;
Evalute(out v, t);
r.material.SetFloat(floatCtrl.propertyName, v);
}
break;
}
}
}
else if (body is MaskableGraphic)
{
MaskableGraphic i = body as MaskableGraphic;
switch (controlType)
{
case ControlType.TintColor:
if (colorCtrl.gradient != null)
i.color = colorCtrl.gradient.Evaluate(t);
break;
case ControlType.UV:
{
Vector4 v;
Evalute(out v, t);
if (i.material)
i.material.SetVector(uvCtrl.propertyName, v);
else if (i is RawImage)
(i as RawImage).uvRect = new Rect(v.z, v.w, v.x, v.y);
}
break;
case ControlType.ShaderValue:
{
if (i.material)
{
float v;
Evalute(out v, t);
i.material.SetFloat(floatCtrl.propertyName, v);
}
}
break;
}
}
else if (body is UIMeshRenderer)
{
UIMeshRenderer r = body as UIMeshRenderer;
switch (controlType)
{
case ControlType.TintColor:
if (colorCtrl.gradient != null)
r.SetColor(colorCtrl.gradient.Evaluate(t));
break;
case ControlType.UV:
{
Vector4 cur;
Evalute(out cur, t);
r.SetUV(uvCtrl.propertyName, cur);
}
break;
case ControlType.ShaderValue:
{
float cur;
Evalute(out cur, t);
r.SetValue(floatCtrl.propertyName, cur);
}
break;
}
}
}
public void SetValue(Vector4 v)
{
if (controlType != ControlType.SequenceTex)
return;
if (body is Renderer)
{
Renderer r = body as Renderer;
if (r.material)
{
r.material.SetTextureScale(uvCtrl.propertyName, new Vector2(v.x, v.y));
r.material.SetTextureOffset(uvCtrl.propertyName, new Vector2(v.z, v.w));
}
}
else if (body is MaskableGraphic)
{
MaskableGraphic i = body as MaskableGraphic;
if (i.material)
i.material.SetVector(uvCtrl.propertyName, v);
else if (i is RawImage)
(i as RawImage).uvRect = new Rect(v.z, v.w, v.x, v.y);
}
else if (body is UIMeshRenderer)
{
(body as UIMeshRenderer).SetUV(uvCtrl.propertyName, v);
}
}
void Evalute(out Vector3 v, float t)
{
if (useEase)
v = Vector3.LerpUnclamped(vectorCtrl.from, vectorCtrl.to, t);
else
{
v.x = Mathf.LerpUnclamped(vectorCtrl.from.x, vectorCtrl.to.x, curves[0].Evaluate(t));
v.y = Mathf.LerpUnclamped(vectorCtrl.from.y, vectorCtrl.to.y, curves[1].Evaluate(t));
v.z = Mathf.LerpUnclamped(vectorCtrl.from.z, vectorCtrl.to.z, curves[2].Evaluate(t));
}
}
void Evalute(out Vector4 v, float t)
{
if (useEase)
v = Vector4.LerpUnclamped(uvCtrl.from, uvCtrl.to, t);
else
{
v.x = Mathf.LerpUnclamped(uvCtrl.from.x, uvCtrl.to.x, curves[0].Evaluate(t));
v.y = Mathf.LerpUnclamped(uvCtrl.from.y, uvCtrl.to.y, curves[1].Evaluate(t));
v.z = Mathf.LerpUnclamped(uvCtrl.from.z, uvCtrl.to.z, curves[2].Evaluate(t));
v.w = Mathf.LerpUnclamped(uvCtrl.from.w, uvCtrl.to.w, curves[3].Evaluate(t));
}
}
void Evalute(out float v, float t)
{
if (useEase)
v = Mathf.LerpUnclamped(floatCtrl.from, floatCtrl.to, t);
else
v = Mathf.LerpUnclamped(floatCtrl.from, floatCtrl.to, curves[0].Evaluate(t));
}
public void HideColor()
{
if (controlType != ControlType.TintColor)
return;
if (body is Renderer)
{
Renderer r = body as Renderer;
if (r.material)
r.material.SetColor(colorCtrl.colorName, new Color(0, 0, 0, 0));
}
else if (body is MaskableGraphic)
{
MaskableGraphic r = body as MaskableGraphic;
if (r.material)
r.material.SetColor(colorCtrl.colorName, new Color(0, 0, 0, 0));
}
else if (body is UIMeshRenderer)
{
//UIMeshRenderer r = body as UIMeshRenderer;
//if (r.material)
// r.material.SetColor(colorCtrl.colorName, new Color(0, 0, 0, 0));
}
}
}
[System.Serializable]
public class Vector3Control
{
public Vector3 from;
public Vector3 to;
public string followHandler;
}
[System.Serializable]
public class ColorControl
{
public string colorName;
public Gradient gradient;
}
[System.Serializable]
public class UVControl
{
public string propertyName;
public Vector4 from;
public Vector4 to;
}
[System.Serializable]
public class FloatControl
{
public string propertyName;
public float from;
public float to;
}
[System.Serializable]
public struct VisableGroup
{
public float delay;
public bool visible;
}
[System.Serializable]
public class Avatar
{
public float delay;
public Vector3 position;
public Vector3 rotation;
public Vector3 scale = Vector3.one;
public float duration = 1;
}
public float delay;
public float[] repeatTimes;
public Vector3 offset;
public Vector3 angleOff;
public Vector3 scale = Vector3.one;
public float instanceExistTime = 1;
public Avatar[] avatars;
public string animationPath;
private bool isBase = true;
public bool IsBase
{
get { return isBase; }
set { isBase = value; }
}
public bool isOriginal = true;
public List<TweenGroup> tweens = new List<TweenGroup>();
private List<Tweener> tweeners = new List<Tweener>();
private Dictionary<Transform, Vector3> posOrgState;
private Dictionary<Transform, Vector3> rotOrgState;
private Dictionary<Transform, Vector3> sclOrgState;
private Dictionary<GameObject, bool> goOrgState;
private Vector3 orgPos = Vector3.zero;
private Vector3 orgRot = Vector3.zero;
private Vector3 orgScl = Vector3.one;
IEnumerator WaitOneFrame(System.Action ac)
{
yield return 1;
ac();
}
private void OnEnable()
{
StartCoroutine(WaitOneFrame(RePlay));
}
private static int Compare(TweenGroup a, TweenGroup b)
{
if (a.delay == b.delay)
{
return 0;
}
if (a.delay > b.delay)
{
return 1;
}
else
{
return -1;
}
}
private void OnDisable()
{
for (int i = 0; i < tweeners.Count; i++)
{
tweeners[i].Kill();
}
tweeners.Clear();
}
public void RePlay()
{
ResetOriginalState();
if (IsBase)
{
orgPos = transform.localPosition;
orgRot = transform.localEulerAngles;
orgScl = transform.localScale;
tweens.Sort(Compare);
}
Delay(delay, Play);
}
System.Collections.IEnumerator StartPlay()
{
if (delay > 0)
{
yield return new WaitForSeconds(delay);
}
}
private void Play()
{
for (int i = 0; i < tweens.Count; i++)
{
tweens[i].worldRot = worldRot;
if (!tweens[i].body)
continue;
switch (tweens[i].controlType)
{
case ControlType.Position:
{
if (tweens[i].vectorCtrl == null)
continue;
Transform tr = tweens[i].body as Transform;
if (posOrgState == null)
posOrgState = new Dictionary<Transform, Vector3>();
if (!posOrgState.ContainsKey(tr))
posOrgState.Add(tr, tr.localPosition);
DoValue(tweens[i]);
break;
}
case ControlType.Rotation:
{
if (tweens[i].vectorCtrl == null)
continue;
Transform tr = tweens[i].body as Transform;
if (rotOrgState == null)
rotOrgState = new Dictionary<Transform, Vector3>();
if (!rotOrgState.ContainsKey(tr))
rotOrgState.Add(tr, tr.localEulerAngles);
DoValue(tweens[i]);
break;
}
case ControlType.Scale:
{
if (tweens[i].vectorCtrl == null)
continue;
Transform tr = tweens[i].body as Transform;
if (sclOrgState == null)
sclOrgState = new Dictionary<Transform, Vector3>();
if (!sclOrgState.ContainsKey(tr))
sclOrgState.Add(tr, tr.localScale);
DoValue(tweens[i]);
break;
}
case ControlType.TintColor:
{
if (tweens[i].colorCtrl == null)
continue;
DoColor(tweens[i]);
break;
}
case ControlType.UV:
{
if (tweens[i].uvCtrl == null)
continue;
DoValue(tweens[i]);
break;
}
case ControlType.SequenceTex:
{
if (tweens[i].uvCtrl == null)
continue;
DoTexSequence(tweens[i]);
break;
}
case ControlType.ShaderValue:
{
if (tweens[i].floatCtrl == null)
continue;
DoValue(tweens[i]);
break;
}
case ControlType.Visible:
{
if (tweens[i].visibles == null)
continue;
GameObject go = tweens[i].body as GameObject;
if (goOrgState == null)
goOrgState = new Dictionary<GameObject, bool>();
if (!goOrgState.ContainsKey(go))
goOrgState.Add(go, go.activeSelf);
DoVisible(tweens[i]);
break;
}
case ControlType.ProjectorPlane:
{
if (tweens[i].visibles == null)
continue;
DoProjector(tweens[i]);
break;
}
}
}
if (IsBase)
{
SpawnRepeatSimple();
SpawnAvatar();
}
}
#region 控制变化
private void DoValue(TweenGroup tg)
{
tweeners.Add(DOTween.To(tg.SetValue, 0f, 1f, tg.duration)
.SetDelay(tg.delay)
.SetEase(tg.useEase ? tg.ease : Ease.Linear)
.SetLoops(tg.loop, tg.loopType));
}
private void DoColor(TweenGroup tg)
{
tweeners.Add(DOTween.To(tg.SetValue, 0f, 1f, tg.duration)
.SetDelay(tg.delay)
.SetEase(Ease.Linear)
.SetLoops(tg.loop, tg.loopType)
.OnKill(tg.HideColor));
}
private void DoTexSequence(TweenGroup tg)
{
int xCount = (int)(1 / tg.uvCtrl.from.x + 0.5f);
int totalCount = xCount * (int)(1 / tg.uvCtrl.from.y + 0.5f);
if (xCount != 0 && totalCount != 0)
{
//tg.SetValue(new Vector4(tg.uvCtrl.from.x, tg.uvCtrl.from.y, 0, 1 - tg.uvCtrl.from.y));
//Delay(tg.delay, delegate { DoTexSequence(tg, xCount, totalCount, tg.duration / totalCount, 1, tg.loop, tg.key); });
//DoTexSequence(tg, xCount, totalCount, tg.duration / totalCount, 1, tg.loop, tg.key);
tg.SetValue(new Vector4(tg.uvCtrl.from.x, tg.uvCtrl.from.y, 0, 1 - tg.uvCtrl.from.y));
tweeners.Add(DOTween.To(EmptySet, 0, tg.delay, tg.delay).SetEase(Ease.Linear).SetId(tg.key).OnComplete(delegate
{
DoTexSequence(tg, xCount, totalCount, tg.duration / totalCount, 1, tg.loop, tg.key);
}));
}
}
private void DoTexSequence(TweenGroup tg, int xCount, int totalCount, float intervalTime, int focus, int loop = -1, int seqKey = 0)
{
if (focus == totalCount && loop > 0)
loop--;
if (loop != 0)
{
focus %= totalCount;
tg.SetValue(new Vector4(tg.uvCtrl.from.x, tg.uvCtrl.from.y, focus % xCount * tg.uvCtrl.from.x, 1 - (1 + focus / xCount) * tg.uvCtrl.from.y));
if (intervalTime > 0)
{
var tw = GetTweenerFromKey(seqKey);
if (tw == null)
{
tweeners.Add(DOTween.To(EmptySet, 0, intervalTime, intervalTime).SetEase(Ease.Linear).SetId(seqKey).OnComplete(delegate
{
DoTexSequence(tg, xCount, totalCount, intervalTime, ++focus, loop, seqKey);
}));
}
else
{
tw.OnComplete(delegate
{
DoTexSequence(tg, xCount, totalCount, intervalTime, ++focus, loop, seqKey);
});
tw.Restart();
}
}
else
{
DoTexSequence(tg, xCount, totalCount, intervalTime, ++focus, loop, seqKey);
}
}
}
private Tweener GetTweenerFromKey(int key)
{
Tweener tw = null;
if (tweeners == null || tweeners.Count < 1) return tw;
for (int i = 0; i < tweeners.Count; i++)
{
if (tweeners[i].id != null && (tweeners[i].id is int) && (int)tweeners[i].id == key)
{
tw = tweeners[i];
break;
}
}
return tw;
}
private void DoVisible(TweenGroup tg)
{
GameObject go = tg.body as GameObject;
for (int i = 0; i < tg.visibles.Length; i++)
{
VisableGroup vg = tg.visibles[i];
Delay(vg.delay, delegate
{
if (vg.visible)
{
ParticleSystem[] pss = go.GetComponentsInChildren<ParticleSystem>(true);
for (int p = 0; p < pss.Length; p++)
pss[p].Clear();
TrailRenderer[] trs = go.GetComponentsInChildren<TrailRenderer>(true);
for (int l = 0; l < trs.Length; l++)
trs[l].Clear();
}
go.SetActive(vg.visible);
});
}
}
private void DoProjector(TweenGroup tg)
{
ProjectorPlane pp = tg.body as ProjectorPlane;
Delay(tg.delay, delegate
{
if (tg.duration == 0)
pp.Projector();
else if (tg.duration == -1)
tweeners.Add(DOTween.To(delegate (float t) { pp.Projector(); }, 0, 1, 1).SetLoops(-1));
else
tweeners.Add(DOTween.To(delegate (float t) { pp.Projector(); }, 0, 1, tg.duration));
});
}
#endregion
#region 控制复生
private void SpawnRepeatSimple()
{
if (repeatTimes != null)
for (int i = 0; i < repeatTimes.Length; i++)
SpawnRepeatSimple(repeatTimes[i], i + 1);
}
private void SpawnRepeatSimple(float delay, int index)
{
Delay(Mathf.Max(0.01f, delay), delegate
{
if (!IsBase)
return;
GameObject ins = Instantiate(this.gameObject);
ins.transform.SetParent(transform.parent);
ins.transform.localScale = new Vector3()
{
x = orgScl.x * Mathf.Pow(scale.x, index),
y = orgScl.y * Mathf.Pow(scale.y, index),
z = orgScl.z * Mathf.Pow(scale.z, index)
};
ins.transform.localPosition = orgPos + offset * index;
ins.transform.localEulerAngles = orgRot + angleOff * index;
EffectControlHelper ech = ins.GetComponent<EffectControlHelper>();
ech.IsBase = false;
Delay(ech.delay + instanceExistTime, delegate { Destroy(ins); }, delegate { Destroy(ins); });
});
}
private void SpawnAvatar()
{
if (avatars != null)
for (int i = 0; i < avatars.Length; i++)
SpawnAvatar(avatars[i]);
}
private void SpawnAvatar(Avatar avatar)
{
Delay(Mathf.Max(0.01f, avatar.delay), delegate
{
if (!IsBase)
return;
GameObject ins = Instantiate(this.gameObject);
ins.transform.SetParent(transform.parent);
ins.transform.localPosition = avatar.position;
ins.transform.localEulerAngles = avatar.rotation;
ins.transform.localScale = avatar.scale;
EffectControlHelper ech = ins.GetComponent<EffectControlHelper>();
ech.IsBase = false;
ech.worldRot = avatar.rotation;
Delay(ech.delay + avatar.duration, delegate { Destroy(ins); }, delegate { Destroy(ins); });
});
}
#endregion
private static void EmptySet(float v)
{
}
private void Delay(float time, TweenCallback onComplete, TweenCallback onKill = null)
{
if (time > 0)
tweeners.Add(
DOTween.To(EmptySet, 0, time, time)
.SetEase(Ease.Linear)
.OnComplete(onComplete)
.OnKill(onKill));
else onComplete();
}
public void ResetOriginalState()
{
if (posOrgState != null)
{
var iter = posOrgState.GetEnumerator();
while (iter.MoveNext())
{
if (iter.Current.Key != null)
{
iter.Current.Key.localPosition = iter.Current.Value;
}
}
iter.Dispose();
}
if (rotOrgState != null)
{
var iter = rotOrgState.GetEnumerator();
while (iter.MoveNext())
{
if (iter.Current.Key != null)
{
iter.Current.Key.localEulerAngles = iter.Current.Value;
}
}
iter.Dispose();
}
if (sclOrgState != null)
{
var iter = sclOrgState.GetEnumerator();
while (iter.MoveNext())
{
if (iter.Current.Key != null)
{
iter.Current.Key.localScale = iter.Current.Value;
}
}
iter.Dispose();
}
if (goOrgState != null)
{
var iter = goOrgState.GetEnumerator();
while (iter.MoveNext())
{
if (iter.Current.Key != null)
{
iter.Current.Key.SetActive(iter.Current.Value);
}
}
iter.Dispose();
}
}
public void BakeToClip(System.Action<AnimationClip> clipCallback)
{
AnimationClip clip = new AnimationClip();
clip.frameRate = 30;
List<TweenGroup> longTimeTweens = new List<TweenGroup>(tweens);
longTimeTweens.Sort((a, b) => (b.delay + b.duration).CompareTo(a.delay + a.duration));
float waitTime = longTimeTweens[0].delay + longTimeTweens[0].duration;
OnDisable();
OnEnable();
Delay(delay, () =>
{
for (int i = 0; i < tweens.Count; i++)
{
TweenGroup tween = tweens[i];
switch (tween.controlType)
{
case ControlType.Position:
{
Transform tr = tween.body as Transform;
string relativePath = GetRelativePath(tr);
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration, () => tr.localPosition.x,
(cx) => clip.SetCurve(relativePath, typeof(Transform), "localPosition.x", cx));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration, () => tr.localPosition.y,
(cy) => clip.SetCurve(relativePath, typeof(Transform), "localPosition.y", cy));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration, () => tr.localPosition.z,
(cz) => clip.SetCurve(relativePath, typeof(Transform), "localPosition.z", cz));
break;
}
case ControlType.Rotation:
{
Transform tr = tween.body as Transform;
string relativePath = GetRelativePath(tr);
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration, () => tr.localEulerAngles.x,
(cx) => clip.SetCurve(relativePath, typeof(Transform), "localEulerAngles.x", cx));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration, () => tr.localEulerAngles.y,
(cy) => clip.SetCurve(relativePath, typeof(Transform), "localEulerAngles.y", cy));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration, () => tr.localEulerAngles.z,
(cz) => clip.SetCurve(relativePath, typeof(Transform), "localEulerAngles.z", cz));
break;
}
case ControlType.Scale:
{
Transform tr = tween.body as Transform;
string relativePath = GetRelativePath(tr);
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration, () => tr.localScale.x,
(cx) => clip.SetCurve(relativePath, typeof(Transform), "localScale.x", cx));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration, () => tr.localScale.y,
(cy) => clip.SetCurve(relativePath, typeof(Transform), "localScale.y", cy));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration, () => tr.localScale.z,
(cz) => clip.SetCurve(relativePath, typeof(Transform), "localScale.z", cz));
break;
}
case ControlType.TintColor:
{
if (tween.body is Renderer)
{
Renderer rd = tween.body as Renderer;
string relativePath = GetRelativePath(rd.transform);
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetColor(tween.colorCtrl.colorName).r,
(cr) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.colorCtrl.colorName + ".r", cr));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetColor(tween.colorCtrl.colorName).g,
(cg) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.colorCtrl.colorName + ".g", cg));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetColor(tween.colorCtrl.colorName).b,
(cb) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.colorCtrl.colorName + ".b", cb));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetColor(tween.colorCtrl.colorName).a,
(ca) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.colorCtrl.colorName + ".a", ca));
}
break;
}
case ControlType.UV:
{
if (tween.body is Renderer)
{
Renderer rd = tween.body as Renderer;
string relativePath = GetRelativePath(rd.transform);
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetColor(tween.uvCtrl.propertyName).r,
(cx) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.uvCtrl.propertyName + ".x", cx));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetColor(tween.uvCtrl.propertyName).g,
(cy) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.uvCtrl.propertyName + ".y", cy));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetColor(tween.uvCtrl.propertyName).b,
(cz) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.uvCtrl.propertyName + ".z", cz));
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetColor(tween.uvCtrl.propertyName).a,
(cw) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.uvCtrl.propertyName + ".w", cw));
}
break;
}
case ControlType.SequenceTex:
{
if (tween.body is Renderer)
{
Renderer rd = tween.body as Renderer;
string relativePath = GetRelativePath(rd.transform);
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetTextureScale(tween.uvCtrl.propertyName).x,
(cx) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.uvCtrl.propertyName + "_ST.x", cx), true);
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetTextureScale(tween.uvCtrl.propertyName).y,
(cy) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.uvCtrl.propertyName + "_ST.y", cy), true);
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetTextureOffset(tween.uvCtrl.propertyName).x,
(cz) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.uvCtrl.propertyName + "_ST.z", cz), true);
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetTextureOffset(tween.uvCtrl.propertyName).y,
(cw) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.uvCtrl.propertyName + "_ST.w", cw), true);
}
break;
}
case ControlType.ShaderValue:
{
Renderer rd = tween.body as Renderer;
string relativePath = GetRelativePath(rd.transform);
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => rd.material.GetFloat(tween.floatCtrl.propertyName),
(cv) => clip.SetCurve(relativePath, typeof(Renderer), "material." + tween.floatCtrl.propertyName, cv));
break;
}
case ControlType.Visible:
{
GameObject go = tween.body as GameObject;
string relativePath = GetRelativePath(go.transform);
RecordCurve(tween, new AnimationCurve(), tween.delay + tween.duration,
() => go.activeSelf ? 1 : 0,
(cv) => clip.SetCurve(relativePath, typeof(GameObject), "m_IsActive", cv), true);
break;
}
}
}
Delay(waitTime + 1, () => clipCallback(clip));
});
}
private string GetRelativePath(Transform tr)
{
string relativePath = "";
if (tr != transform)
{
relativePath = tr.name;
while (tr.parent != transform)
{
tr = tr.parent;
relativePath = string.Format("{0}/{1}", tr.name, relativePath);
}
}
return relativePath;
}
private void RecordCurve(TweenGroup tween, AnimationCurve curve, float duration, System.Func<float> value, System.Action<AnimationCurve> result, bool constant = false)
{
int frame = (int)(duration * 30 + 0.5f);
for (int count = 0; count <= frame; count++)
{
float time = Mathf.Lerp(0, duration, (float)count / frame);
Delay(time, () =>
{
Keyframe key = new Keyframe(time, value());
key.tangentMode = constant ? 103 : 34;//103 is Constant , 34 is Auto
if (curve.keys.Length > 1)
{
key.inTangent = constant ? float.PositiveInfinity : (value() - curve.keys[curve.keys.Length - 1].value) / (time - curve.keys[curve.keys.Length - 1].time);
key.outTangent = constant ? float.PositiveInfinity : (value() - curve.keys[curve.keys.Length - 1].value) / (time - curve.keys[curve.keys.Length - 1].time);
}
curve.AddKey(key);
});
}
Delay(duration + 0.5f, () => result(curve));
}
}