public static void ApplyValueLerp(AMMaterialTrack.ValueType valueType, string prop, int propId, Material mat, AMMaterialKey fromKey, AMMaterialKey toKey, float t)
{
switch (valueType)
{
case AMMaterialTrack.ValueType.Float:
case AMMaterialTrack.ValueType.Range:
mat.SetFloat(propId, Mathf.Lerp(fromKey.val, toKey.val, t));
break;
case AMMaterialTrack.ValueType.Vector:
mat.SetVector(propId, Vector4.Lerp(fromKey.vector, toKey.vector, t));
break;
case AMMaterialTrack.ValueType.Color:
mat.SetColor(propId, Color.Lerp(fromKey.color, toKey.color, t));
break;
case AMMaterialTrack.ValueType.TexOfs:
mat.SetTextureOffset(prop, Vector2.Lerp(fromKey.texOfs, toKey.texOfs, t));
break;
case AMMaterialTrack.ValueType.TexScale:
mat.SetTextureScale(prop, Vector2.Lerp(fromKey.texScale, toKey.texScale, t));
break;
}
}
public void ApplyValue(AMMaterialTrack.ValueType valueType, string prop, int propId, Material mat)
{
switch (valueType)
{
case AMMaterialTrack.ValueType.Float:
case AMMaterialTrack.ValueType.Range:
mat.SetFloat(propId, val);
break;
case AMMaterialTrack.ValueType.Vector:
mat.SetVector(propId, vector);
break;
case AMMaterialTrack.ValueType.Color:
mat.SetColor(propId, color);
break;
case AMMaterialTrack.ValueType.TexEnv:
mat.SetTexture(propId, texture);
break;
case AMMaterialTrack.ValueType.TexOfs:
mat.SetTextureOffset(prop, texOfs);
break;
case AMMaterialTrack.ValueType.TexScale:
mat.SetTextureScale(prop, texScale);
break;
}
}
public bool targetsAreEqual(AMMaterialTrack.ValueType valueType, AMMaterialKey nextKey)
{
if (nextKey)
{
if (valueType == AMMaterialTrack.ValueType.Float || valueType == AMMaterialTrack.ValueType.Range)
{
return(val == nextKey.val);
}
if (valueType == AMMaterialTrack.ValueType.Vector)
{
return(vector == nextKey.vector);
}
if (valueType == AMMaterialTrack.ValueType.Color)
{
return(color == nextKey.color);
}
if (valueType == AMMaterialTrack.ValueType.TexOfs)
{
return(texOfs == nextKey.texOfs);
}
if (valueType == AMMaterialTrack.ValueType.TexScale)
{
return(texScale == nextKey.texScale);
}
}
return(true);
}
public string getValueString(AMMaterialTrack.ValueType valueType, AMMaterialKey nextKey, bool brief)
{
System.Text.StringBuilder s = new System.Text.StringBuilder();
switch (valueType)
{
case AMMaterialTrack.ValueType.Float:
case AMMaterialTrack.ValueType.Range:
s.Append(formatNumeric(val));
if (!brief && nextKey)
{
s.Append(" -> "); s.Append(formatNumeric(nextKey.val));
}
break;
case AMMaterialTrack.ValueType.Vector:
s.Append(_val4.ToString());
if (!brief && nextKey)
{
s.Append(" -> "); s.Append(nextKey._val4.ToString());
}
break;
case AMMaterialTrack.ValueType.Color:
s.Append(color.ToString());
if (!brief && nextKey)
{
s.Append(" -> "); s.Append(nextKey.color.ToString());
}
break;
case AMMaterialTrack.ValueType.TexEnv:
s.Append(texture ? texture.name : "None");
break;
case AMMaterialTrack.ValueType.TexOfs:
s.Append(texOfs.ToString());
if (!brief && nextKey)
{
s.Append(" -> "); s.Append(nextKey.texOfs.ToString());
}
break;
case AMMaterialTrack.ValueType.TexScale:
s.Append(texScale.ToString());
if (!brief && nextKey)
{
s.Append(" -> "); s.Append(nextKey.texScale.ToString());
}
break;
}
return(s.ToString());
}
void GetPropertyInfos(Material mat, out string[] names, out string[] details, out AMMaterialTrack.ValueType[] types, out int[] inds)
{
Shader shader = mat.shader;
int count = ShaderUtil.GetPropertyCount(shader);
List <string> _names = new List <string>();
List <AMMaterialTrack.ValueType> _types = new List <AMMaterialTrack.ValueType>();
for (int i = 0; i < count; i++)
{
var name = ShaderUtil.GetPropertyName(shader, i);
var type = ShaderUtil.GetPropertyType(shader, i);
_names.Add(name);
_types.Add((AMMaterialTrack.ValueType)type);
if (type == ShaderUtil.ShaderPropertyType.TexEnv)
{
_names.Add(name); _types.Add(AMMaterialTrack.ValueType.TexOfs);
_names.Add(name); _types.Add(AMMaterialTrack.ValueType.TexScale);
}
}
count = _names.Count;
names = new string[count];
details = new string[count];
types = new AMMaterialTrack.ValueType[count];
inds = new int[count];
for (int i = 0; i < count; i++)
{
names[i] = _names[i];
types[i] = _types[i];
switch (types[i])
{
case AMMaterialTrack.ValueType.TexOfs:
details[i] = string.Format("{0} Offset", names[i]);
break;
case AMMaterialTrack.ValueType.TexScale:
details[i] = string.Format("{0} Scale", names[i]);
break;
default:
details[i] = names[i];
break;
}
inds[i] = i;
}
}
void GetPropertyInfos(Material mat, out string[] names, out string[] details, out AMMaterialTrack.ValueType[] types, out int[] inds)
{
Shader shader = mat.shader;
int count = ShaderUtil.GetPropertyCount(shader);
List<string> _names = new List<string>();
List<AMMaterialTrack.ValueType> _types = new List<AMMaterialTrack.ValueType>();
for(int i = 0; i < count; i++) {
var name = ShaderUtil.GetPropertyName(shader, i);
var type = ShaderUtil.GetPropertyType(shader, i);
_names.Add(name);
_types.Add((AMMaterialTrack.ValueType)type);
if(type == ShaderUtil.ShaderPropertyType.TexEnv) {
_names.Add(name); _types.Add(AMMaterialTrack.ValueType.TexOfs);
_names.Add(name); _types.Add(AMMaterialTrack.ValueType.TexScale);
}
}
count = _names.Count;
names = new string[count];
details = new string[count];
types = new AMMaterialTrack.ValueType[count];
inds = new int[count];
for(int i = 0; i < count; i++) {
names[i] = _names[i];
types[i] = _types[i];
switch(types[i]) {
case AMMaterialTrack.ValueType.TexOfs:
details[i] = string.Format("{0} Offset", names[i]);
break;
case AMMaterialTrack.ValueType.TexScale:
details[i] = string.Format("{0} Scale", names[i]);
break;
default:
details[i] = names[i];
break;
}
inds[i] = i;
}
}
public object getValue(AMMaterialTrack.ValueType valueType)
{
if (valueType == AMMaterialTrack.ValueType.TexEnv)
{
return(texture ? texture : null);
}
if (valueType == AMMaterialTrack.ValueType.Vector)
{
return(vector);
}
if (valueType == AMMaterialTrack.ValueType.Color)
{
return(color);
}
if (valueType == AMMaterialTrack.ValueType.TexOfs)
{
return(texOfs);
}
if (valueType == AMMaterialTrack.ValueType.TexScale)
{
return(texScale);
}
return(val);
}
public override void build(AMSequence seq, AMTrack track, int index, UnityEngine.Object target)
{
AMMaterialTrack matTrack = track as AMMaterialTrack;
AMMaterialTrack.ValueType propType = matTrack.propertyType;
Material matInst = matTrack.materialInstance;
string prop = matTrack.property;
int propId = Shader.PropertyToID(prop);
int frameRate = seq.take.frameRate;
Tweener tween = null;
int keyCount = track.keys.Count;
AMMaterialKey endKey = index + 1 < keyCount ? track.keys[index + 1] as AMMaterialKey : null;
float frameCount = endKey != null ? endKey.frame - frame + 1 : 1f;
switch (propType)
{
case AMMaterialTrack.ValueType.Float:
case AMMaterialTrack.ValueType.Range:
if (!canTween || keyCount == 1) //allow one key
{
var setTween = DOTween.To(new AMPlugValueSet <float>(), () => val, (x) => matInst.SetFloat(propId, x), val, frameCount / frameRate);
setTween.plugOptions.SetSequence(seq);
seq.Insert(this, setTween);
}
else
{
if (targetsAreEqual(propType, endKey))
{
return;
}
tween = DOTween.To(new FloatPlugin(), () => matInst.GetFloat(propId), (x) => matInst.SetFloat(propId, x), endKey.val, getTime(frameRate));
}
break;
case AMMaterialTrack.ValueType.Vector:
if (!canTween || keyCount == 1) //allow one key
{
var setTween = DOTween.To(new AMPlugValueSet <Vector4>(), () => vector, (x) => matInst.SetVector(propId, x), vector, frameCount / frameRate);
setTween.plugOptions.SetSequence(seq);
seq.Insert(this, setTween);
}
else
{
if (targetsAreEqual(propType, endKey))
{
return;
}
tween = DOTween.To(AMPluginFactory.CreateVector4(), () => matInst.GetVector(propId), (x) => matInst.SetVector(propId, x), endKey.vector, getTime(frameRate));
}
break;
case AMMaterialTrack.ValueType.Color:
if (!canTween || keyCount == 1) //allow one key
{
var val = color;
var setTween = DOTween.To(new AMPlugValueSet <Color>(), () => val, (x) => matInst.SetColor(propId, x), val, frameCount / frameRate);
setTween.plugOptions.SetSequence(seq);
seq.Insert(this, setTween);
}
else
{
if (targetsAreEqual(propType, endKey))
{
return;
}
tween = DOTween.To(AMPluginFactory.CreateColor(), () => matInst.GetColor(propId), (x) => matInst.SetColor(propId, x), endKey.color, getTime(frameRate));
}
break;
case AMMaterialTrack.ValueType.TexOfs:
if (!canTween || keyCount == 1) //allow one key
{
var val = texOfs;
var setTween = DOTween.To(new AMPlugValueSet <Vector2>(), () => val, (x) => matInst.SetTextureOffset(prop, x), val, frameCount / frameRate);
setTween.plugOptions.SetSequence(seq);
seq.Insert(this, setTween);
}
else
{
if (targetsAreEqual(propType, endKey))
{
return;
}
tween = DOTween.To(AMPluginFactory.CreateVector2(), () => matInst.GetTextureOffset(prop), (x) => matInst.SetTextureOffset(prop, x), endKey.texOfs, getTime(frameRate));
}
break;
case AMMaterialTrack.ValueType.TexScale:
if (!canTween || keyCount == 1) //allow one key
{
var val = texScale;
var setTween = DOTween.To(new AMPlugValueSet <Vector2>(), () => val, (x) => matInst.SetTextureScale(prop, x), val, frameCount / frameRate);
setTween.plugOptions.SetSequence(seq);
seq.Insert(this, setTween);
}
else
{
if (targetsAreEqual(propType, endKey))
{
return;
}
tween = DOTween.To(AMPluginFactory.CreateVector2(), () => matInst.GetTextureScale(prop), (x) => matInst.SetTextureScale(prop, x), endKey.texScale, getTime(frameRate));
}
break;
case AMMaterialTrack.ValueType.TexEnv:
var texEnvTween = DOTween.To(new AMPlugValueSet <Texture>(), () => texture, (x) => matInst.SetTexture(propId, x), texture, frameCount / frameRate);
texEnvTween.plugOptions.SetSequence(seq);
seq.Insert(this, texEnvTween);
break;
}
if (tween != null)
{
if (hasCustomEase())
{
tween.SetEase(easeCurve);
}
else
{
tween.SetEase((Ease)easeType, amplitude, period);
}
seq.Insert(this, tween);
}
}
void OnGUI()
{
AMTimeline.loadSkin(ref skin, ref cachedSkinName, position);
if (aData == null)
{
AMTimeline.MessageBox("Animator requires an AnimatorData component in your scene. Launch Animator to add the component.", AMTimeline.MessageBoxType.Warning);
return;
}
if (!mTrack)
{
return;
}
Renderer render = mTrack.GetTarget(aData.target) as Renderer;
if (!render)
{
AMTimeline.MessageBox("Assign a Renderer to the track first.", AMTimeline.MessageBoxType.Warning);
return;
}
//select material
Material[] mats = render.sharedMaterials;
string[] matNames = new string[mats.Length];
int[] matInds = new int[mats.Length];
for (int i = 0; i < mats.Length; i++)
{
matNames[i] = mats[i].name;
matInds[i] = i;
}
//grab track info
int matInd = Mathf.Clamp(mTrack.materialIndex, 0, mats.Length - 1);
Material matOverride = mTrack.materialOverride;
string shaderProperty = mTrack.property;
//material select
matInd = EditorGUILayout.IntPopup("Material", matInd, matNames, matInds);
//material override select
matOverride = EditorGUILayout.ObjectField("Material Override", matOverride, typeof(Material), false) as Material;
Material mat = matOverride ? matOverride : mats[matInd];
//grab material info
string[] shaderPropertyNames, shaderPropertyDetails;
AMMaterialTrack.ValueType[] shaderPropertyTypes;
int[] shaderPropertyInds;
GetPropertyInfos(mat, out shaderPropertyNames, out shaderPropertyDetails, out shaderPropertyTypes, out shaderPropertyInds);
int shaderPropertyInd = -1;
AMMaterialTrack.ValueType shaderPropertyType = mTrack.propertyType;
for (int i = 0; i < shaderPropertyNames.Length; i++)
{
if (shaderProperty == shaderPropertyNames[i])
{
shaderPropertyInd = i;
//special case for texture offset and scale
if (shaderPropertyTypes[i] == AMMaterialTrack.ValueType.TexEnv && i + 2 < shaderPropertyNames.Length)
{
if (shaderPropertyType == shaderPropertyTypes[i + 1])
{
shaderPropertyInd += 1;
}
else if (shaderPropertyType == shaderPropertyTypes[i + 2])
{
shaderPropertyInd += 2;
}
}
break;
}
}
if (shaderPropertyInd == -1)
{
shaderPropertyInd = 0;
}
EditorUtility.DrawSeparator();
//shader property select
shaderPropertyInd = EditorGUILayout.IntPopup("Property", shaderPropertyInd, shaderPropertyDetails, shaderPropertyInds);
shaderProperty = shaderPropertyNames[shaderPropertyInd];
shaderPropertyType = shaderPropertyTypes[shaderPropertyInd];
//check for change
if (mTrack.materialIndex != matInd || mTrack.materialOverride != matOverride || mTrack.property != shaderProperty || mTrack.propertyType != shaderPropertyType)
{
Undo.RecordObject(mTrack, "Material Track Property Change");
mTrack.materialIndex = matInd;
mTrack.materialOverride = matOverride;
mTrack.property = shaderProperty;
mTrack.propertyType = shaderPropertyType;
}
}
