//格式:name:值0 value1 value2,持续时间,恢复时间
public void ShaderParam(AnimationEvent animEvent)
{
List <ShaderParamNameAndValue> shaderParamsCall = new List <ShaderParamNameAndValue>();
try
{
float loopTime = 0;
float gobackTime = 0;
Renderer[] renders = gameObject.GetComponentsInChildren <Renderer>();
if (renders.Length == 0)
{
return;
}
string[] shaderParams = animEvent.stringParameter.Split(new char[1] {
','
});
int startParamIndex = shaderParamsCall.Count;
int segmentIndex = 0;
foreach (string p in shaderParams)
{
string[] nameAndValue = p.Split(new char[1] {
':'
});
if (nameAndValue.Length == 1)
{//这个字段是持续时间
if (segmentIndex == 0)
{
loopTime = float.Parse(p);
}
else
{
gobackTime = float.Parse(p);
segmentIndex = 0;
}
segmentIndex += 1;
continue;
}
ShaderParamNameAndValue param = new ShaderParamNameAndValue();
param.m_name = nameAndValue[0];
string[] values = nameAndValue[1].Split(new char[1] {
' '
});
if (values.Length == 1)
{
param.m_valueFloat = float.Parse(values[0]);
param.m_type = ENParamType.enFloat;
foreach (Renderer r in renders)
{
if (r.sharedMaterial.HasProperty(param.m_name))
{
Material sharedMaterial = BackupSharedMaterial(r);
param.m_valueStartFloat = sharedMaterial.GetFloat(param.m_name);
break;
}
}
}
else if (values.Length == 3)
{
Color c = Color.white;
c.r = int.Parse(values[0]) / 255.0f;
c.g = int.Parse(values[1]) / 255.0f;
c.b = int.Parse(values[2]) / 255.0f;
c.a = 1.0f;
param.m_valueColor = c;
param.m_type = ENParamType.enColor;
foreach (Renderer r in renders)
{
if (r.sharedMaterial.HasProperty(param.m_name))
{
Material sharedMaterial = BackupSharedMaterial(r);
param.m_valueStartColor = sharedMaterial.GetColor(param.m_name);
break;
}
}
}
else if (values.Length == 4)
{
Vector4 c;
c.x = float.Parse(values[0]);
c.y = float.Parse(values[1]);
c.z = float.Parse(values[2]);
c.w = float.Parse(values[3]);
param.m_valueVec4 = c;
param.m_type = ENParamType.enVector;
foreach (Renderer r in renders)
{
if (r.sharedMaterial.HasProperty(param.m_name))
{
Material sharedMaterial = BackupSharedMaterial(r);
param.m_valueStartVec4 = sharedMaterial.GetVector(param.m_name);
break;
}
}
}
shaderParamsCall.Add(param);
}
for (int i = startParamIndex; i < shaderParamsCall.Count; i++)
{
ShaderParamNameAndValue param = shaderParamsCall[i];
param.m_loopTime = loopTime;
param.m_goTime = 0.0f;
param.m_backTime = gobackTime;
}
StartCoroutine(Cor_ShaderParam(shaderParamsCall, m_testID++));
}
catch (System.Exception)
{
Debug.LogError("ShaderParam error:" + animEvent.stringParameter);
}
}
IEnumerator Cor_ShaderParam(List <ShaderParamNameAndValue> shaderParams, int id)
{
List <Material> mats = new List <Material>();
Renderer[] renders = gameObject.GetComponentsInChildren <Renderer>();
foreach (Renderer r in renders)
{
mats.Add(r.material);
}
//float t = gotime;
while (shaderParams.Count > 0)
{
for (int i = 0; i < shaderParams.Count;)
{
ShaderParamNameAndValue param = shaderParams[i];
param.m_goTime += Time.deltaTime;
float s = param.m_goTime / param.m_loopTime;
if (s > 1.0f || param.m_loopTime <= 0.000001f)
{
s = 1;
if (param.m_isgoback)
{
shaderParams.RemoveAt(i);
}
else
{
//go back value
param.m_isgoback = true;
param.m_goTime = 0;
param.m_loopTime = param.m_backTime;
switch (param.m_type)
{
case ENParamType.enFloat:
{
float vbackup = param.m_valueStartFloat;
param.m_valueStartFloat = param.m_valueFloat;
param.m_valueFloat = vbackup;
}
break;
case ENParamType.enColor:
{
Color vbackup = param.m_valueStartColor;
param.m_valueStartColor = param.m_valueColor;
param.m_valueColor = vbackup;
}
break;
case ENParamType.enVector:
{
Vector4 vbackup = param.m_valueStartVec4;
param.m_valueStartVec4 = param.m_valueVec4;
param.m_valueVec4 = vbackup;
}
break;
}
}
}
else
{
i++;
}
float vfloat = 0;
switch (param.m_type)
{
case ENParamType.enFloat:
vfloat = param.m_valueStartFloat + s * (param.m_valueFloat - param.m_valueStartFloat);
foreach (Material r in mats)
{
if (r.HasProperty(param.m_name))
{
r.SetFloat(param.m_name, vfloat);
}
}
break;
case ENParamType.enColor:
{
Color v = param.m_valueStartColor + s * (param.m_valueColor - param.m_valueStartColor);
foreach (Material r in mats)
{
if (r.HasProperty(param.m_name))
{
r.SetColor(param.m_name, v);
}
}
}
break;
case ENParamType.enVector:
{
Vector4 v = param.m_valueStartVec4 + s * (param.m_valueVec4 - param.m_valueStartVec4);
foreach (Material r in mats)
{
if (r.HasProperty(param.m_name))
{
r.SetVector(param.m_name, v);
}
}
}
break;
}
}
yield return(1);
}
// foreach (Material r in mats)
// {
//DestroyImmediate(r);
// }
// foreach (Renderer r in renders)
// {
//r.material.CopyPropertiesFromMaterial(r.sharedMaterial);
// }
}
