static bool CompareProperty(Material a, Material b, int propID)
{
string propName = ShaderUtil.GetPropertyName(a.shader, propID);
if (propName.Equals("_MainTex") || propName.Equals(MaterialExtension.LIGHTMAP_KEY) || propName.Equals(MaterialExtension.AO_KEY))
{
return(true);
}
ShaderUtil.ShaderPropertyType propType = ShaderUtil.GetPropertyType(a.shader, propID);
if (propType == ShaderUtil.ShaderPropertyType.Color)
{
return(a.GetColor(propName).Equals(b.GetColor(propName)));
}
if (propType == ShaderUtil.ShaderPropertyType.Float || propType == ShaderUtil.ShaderPropertyType.Range)
{
return(Mathf.Abs(a.GetFloat(propName) - b.GetFloat(propName)) < float.Epsilon);
}
if (propType == ShaderUtil.ShaderPropertyType.TexEnv)
{
Texture texA = a.GetTexture(propName);
Texture texB = b.GetTexture(propName);
return(texA && texB && texA.Equals(texB));
}
return(false);
}
/// <summary>
/// DO NOT USE: Working on, where every texture is grabbed from the object
/// </summary>
public static void ExportTextureFromAMesh(MeshRenderer meshRenderer, string materialFolder, string fullTextureFolder)
{
// 1. Need to copy the texture to the new path
// Go through all materials in the mesh renderer and export them as some materials
int length = meshRenderer.sharedMaterials.Length;
for (int materialIndex = 0; materialIndex < length; materialIndex++)
{
Material currentMaterial = meshRenderer.sharedMaterials[materialIndex];
Shader shader = currentMaterial.shader;
int propertyCount = ShaderUtil.GetPropertyCount(shader);
// Copies all the textures to the file
for (int i = 0; i < propertyCount; i++)
{
ShaderUtil.ShaderPropertyType propType = ShaderUtil.GetPropertyType(shader, i);
if (propType == ShaderUtil.ShaderPropertyType.TexEnv)
{
Texture texture = currentMaterial.GetTexture(ShaderUtil.GetPropertyName(shader, i));
if (texture != null)
{
string texturePath = UtiltiesHiFi.GetAssetPathFolder() + AssetDatabase.GetAssetOrScenePath(texture);
string newTextureName = UtiltiesHiFi.GetFileName(texturePath);
string newTexturePathAndName = fullTextureFolder + newTextureName;
File.Copy(texturePath, newTexturePathAndName);
}
}
}
}
}
public static void SetTexturesWriteFlags(SkinnedMeshRenderer[] renderers, bool flag)
{
#if UNITY_EDITOR
foreach (SkinnedMeshRenderer renderer in renderers)
{
foreach (Material mat in renderer.sharedMaterials)
{
int propertyCount = ShaderUtil.GetPropertyCount(mat.shader);
for (int i = 0; i < propertyCount; i++)
{
string propName = ShaderUtil.GetPropertyName(mat.shader, i);
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(mat.shader, i);
if (type == ShaderUtil.ShaderPropertyType.TexEnv)
{
Texture texture = mat.GetTexture(propName);
//Change texture readable flag from Texture Importer
string pass = AssetDatabase.GetAssetPath(texture);
TextureImporter ti = TextureImporter.GetAtPath(pass) as TextureImporter;
ti.isReadable = flag;
ti.textureFormat = TextureImporterFormat.RGBA32;
AssetDatabase.ImportAsset(pass);
}
}
}
}
#endif
}
protected void updateKeys()
{
if (mTarget.replaceMaterial != null)
{
Shader shader = mTarget.replaceMaterial.shader;
int len = ShaderUtil.GetPropertyCount(shader);
keys.Clear();
max.Clear();
max.Clear();
def.Clear();
for (int i = 0; i < len; i++)
{
string g = ShaderUtil.GetPropertyName(shader, i);
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(shader, i);
if (type == ShaderUtil.ShaderPropertyType.Range)
{
def[g] = ShaderUtil.GetRangeLimits(shader, i, 0);
min[g] = ShaderUtil.GetRangeLimits(shader, i, 1);
max[g] = ShaderUtil.GetRangeLimits(shader, i, 2);
keys.Add(g);
}
if (type == ShaderUtil.ShaderPropertyType.Color)
{
Color color = mTarget.replaceMaterial.GetColor(g);
colors.Add(g, color);
colorKeys = colors.Keys.ToArray();
}
}
}
}
/// <summary>
/// Editor 环境转成本地的类型
/// </summary>
/// <param name="propertyType"></param>
/// <returns></returns>
public ShaderPropertyEnum ShaderPropertyType2ShaderPropertyEnum(ShaderUtil.ShaderPropertyType propertyType)
{
switch (propertyType)
{
case ShaderUtil.ShaderPropertyType.Color:
return(ShaderPropertyEnum.Color);
case ShaderUtil.ShaderPropertyType.Vector:
return(ShaderPropertyEnum.Vector);
case ShaderUtil.ShaderPropertyType.Float:
return(ShaderPropertyEnum.Float);
case ShaderUtil.ShaderPropertyType.Range:
return(ShaderPropertyEnum.Range);
case ShaderUtil.ShaderPropertyType.TexEnv:
return(ShaderPropertyEnum.TexEnv);
default:
return(ShaderPropertyEnum.Color);
break;
}
}
public List <KeyValuePair <string, Texture> > GetTexturesFromMaterial(Material material)
{
#if UNITY_EDITOR
List <KeyValuePair <string, Texture> > textures = new List <KeyValuePair <string, Texture> >();
Shader shader = material.shader;
if (shader == null)
{
return(null);
}
int propertyCount = ShaderUtil.GetPropertyCount(shader);
for (int i = 0; i < propertyCount; i++)
{
string propertyName = ShaderUtil.GetPropertyName(shader, i);
ShaderUtil.ShaderPropertyType propertyType = ShaderUtil.GetPropertyType(shader, i);
if (propertyType == ShaderUtil.ShaderPropertyType.TexEnv)
{
Texture tex = material.GetTexture(propertyName);
if (tex != null)
{
textures.Add(new KeyValuePair <string, Texture>(tex.name, tex));
}
}
}
return(textures);
#else
return(null);
#endif
}
// factory for returning shader property for material at index
static public ShaderProperty Get(Material material, int index)
{
Shader shader = material.shader;
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(shader, index);
switch (type)
{
case ShaderUtil.ShaderPropertyType.Float:
return(new ShaderPropertyFloat(material, index));
case ShaderUtil.ShaderPropertyType.Range:
return(new ShaderPropertyRange(material, index));
case ShaderUtil.ShaderPropertyType.TexEnv:
return(new ShaderPropertyTexEnv(material, index));
case ShaderUtil.ShaderPropertyType.Vector:
return(new ShaderPropertyVector(material, index));
case ShaderUtil.ShaderPropertyType.Color:
return(new ShaderPropertyColor(material, index));
default:
throw new UnityException("Shader property type not supported");
}
}
public ShaderTexValue(string n, ShaderUtil.ShaderPropertyType t, Material mat)
: base(n, t)
{
value = mat.GetTexture(n);
offset = mat.GetTextureOffset(n);
scale = mat.GetTextureScale(n);
}
public ShaderProperty(string _name, ShaderUtil.ShaderPropertyType _propertyType)
{
PropertyName = _name;
switch (_propertyType)
{
case ShaderUtil.ShaderPropertyType.Color:
PropertyType = eShaderPropertyType.COLOR;
break;
case ShaderUtil.ShaderPropertyType.Vector:
PropertyType = eShaderPropertyType.VECTOR;
break;
case ShaderUtil.ShaderPropertyType.Float:
PropertyType = eShaderPropertyType.FLOAT;
break;
case ShaderUtil.ShaderPropertyType.Range:
PropertyType = eShaderPropertyType.RANGE;
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
PropertyType = eShaderPropertyType.TEXTURE;
break;
default:
throw new Exception("[ShaderUtility] Unknown type.");
}
}
public List <ShaderInformations> GetAllShaderProperties()
{
Shader shader = GetComponent <Renderer>().sharedMaterial.shader;
List <ShaderInformations> allInfos = new List <ShaderInformations>();
int propertyCount = ShaderUtil.GetPropertyCount(shader);
for (int i = 0; i < propertyCount; i++)
{
string description = ShaderUtil.GetPropertyDescription(shader, i);
string name = ShaderUtil.GetPropertyName(shader, i);
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(shader, i);
ShaderInformations shaderInfo = new ShaderInformations(name, description, type);
if (type == ShaderUtil.ShaderPropertyType.Range)
{
shaderInfo.SetRange(ShaderUtil.GetRangeLimits(shader, i, 0), ShaderUtil.GetRangeLimits(shader, i, 1), ShaderUtil.GetRangeLimits(shader, i, 2));
}
allInfos.Add(shaderInfo);
}
return(allInfos);
}
public ShaderProperty(Material _material, int _index, ShaderUtil.ShaderPropertyType _type)
{
material = _material;
name = ShaderUtil.GetPropertyName(material.shader, _index);
description = ShaderUtil.GetPropertyDescription(material.shader, _index);
id = Shader.PropertyToID(name);
type = _type;
}
public static string MaterialPropertyName(string property, Material mat, ShaderUtil.ShaderPropertyType type, bool allowNone = true, string defaultProperty = "_Color")
{
Color tColor = GUI.color;
// Create a list of available color and value properties
List <string> props = new List <string>();
int selectedPropIndex = 0;
if (allowNone)
{
props.Add("(None)");
}
if (mat != null)
{
int propertyCount = ShaderUtil.GetPropertyCount(mat.shader);
string propName = string.Empty;
for (int i = 0; i < propertyCount; i++)
{
if (ShaderUtil.GetPropertyType(mat.shader, i) == type)
{
propName = ShaderUtil.GetPropertyName(mat.shader, i);
if (propName == property)
{
// We've found our current property
selectedPropIndex = props.Count;
}
props.Add(propName);
}
}
GUI.color = string.IsNullOrEmpty(property) ? HUXEditorUtils.DisabledColor : HUXEditorUtils.DefaultColor;
int newPropIndex = EditorGUILayout.Popup(type.ToString(), selectedPropIndex, props.ToArray());
if (allowNone)
{
property = (newPropIndex > 0 ? props[newPropIndex] : string.Empty);
}
else
{
if (props.Count > 0)
{
property = props[newPropIndex];
}
else
{
property = defaultProperty;
}
}
GUI.color = HUXEditorUtils.DefaultColor;
return(property);
}
else
{
WarningMessage("Can't get material " + type.ToString() + " properties because material is null.");
GUI.color = HUXEditorUtils.DefaultColor;
return(string.Empty);
}
}
/*
* private static string[] kShaderLevels = new string[]
* {
* "Fixed function",
* "SM1.x",
* "SM2.0",
* "SM3.0",
* "SM4.0",
* "SM5.0"
* };
*/
private static string GetPropertyType(Shader s, int index)
{
ShaderUtil.ShaderPropertyType propertyType = ShaderUtil.GetPropertyType(s, index);
if (propertyType == ShaderUtil.ShaderPropertyType.TexEnv)
{
return(ShaderForgeInspector.kTextureTypes[(int)ShaderUtil.GetTexDim(s, index)]);
}
return(ShaderForgeInspector.kPropertyTypes[(int)propertyType]);
}
// This function will look for all referenced lit material, and assign value from Lit to layered lit layers.
// This is based on the naming of the variables, i.E BaseColor will match BaseColor0, if a properties shouldn't be override
// put the name in the exclusionList below
static void SynchronizeLayerProperties(Material material, Material[] layers, int layerIndex, bool excludeUVMappingProperties)
{
Material layerMaterial = layers[layerIndex];
string[] exclusionList = { kTexWorldScale, kUVBase, kUVMappingMask, kUVDetail, kUVDetailsMappingMask };
if (layerMaterial != null)
{
Shader layerShader = layerMaterial.shader;
int propertyCount = ShaderUtil.GetPropertyCount(layerShader);
for (int i = 0; i < propertyCount; ++i)
{
string propertyName = ShaderUtil.GetPropertyName(layerShader, i);
string layerPropertyName = propertyName + layerIndex;
if (!exclusionList.Contains(propertyName) || !excludeUVMappingProperties)
{
if (material.HasProperty(layerPropertyName))
{
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(layerShader, i);
switch (type)
{
case ShaderUtil.ShaderPropertyType.Color:
{
material.SetColor(layerPropertyName, layerMaterial.GetColor(propertyName));
break;
}
case ShaderUtil.ShaderPropertyType.Float:
case ShaderUtil.ShaderPropertyType.Range:
{
material.SetFloat(layerPropertyName, layerMaterial.GetFloat(propertyName));
break;
}
case ShaderUtil.ShaderPropertyType.Vector:
{
material.SetVector(layerPropertyName, layerMaterial.GetVector(propertyName));
break;
}
case ShaderUtil.ShaderPropertyType.TexEnv:
{
material.SetTexture(layerPropertyName, layerMaterial.GetTexture(propertyName));
if (!excludeUVMappingProperties)
{
material.SetTextureOffset(layerPropertyName, layerMaterial.GetTextureOffset(propertyName));
material.SetTextureScale(layerPropertyName, layerMaterial.GetTextureScale(propertyName));
}
break;
}
}
}
}
}
}
}
private static string GetPropertyType(Shader s, int index)
{
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(s, index);
if (type == ShaderUtil.ShaderPropertyType.TexEnv)
{
return(kTextureTypes[(int)ShaderUtil.GetTexDim(s, index)]);
}
return(kPropertyTypes[(int)type]);
}
private List <string> GenerateNonTexturePropertyTokenList(Material material, int propertyIndex)
{
List <string> result = new List <string>();
ShaderUtil.ShaderPropertyType propertyType = ShaderUtil.GetPropertyType(material.shader, propertyIndex);
string propertyName = ShaderUtil.GetPropertyName(material.shader, propertyIndex);
result.Add(propertyType.ToString());
result.Add(propertyName);
result.AddRange(FormatNonTextureProperty(material, propertyType, propertyName));
return(result);
}
public void SetupMaterialInfo()
{
material = new Material(Shader);
int propertyCount = ShaderUtil.GetPropertyCount(Shader);
List <MaterialPropertyWrapper> propertiesToAdd = new List <MaterialPropertyWrapper>();
for (int i = 0; i < propertyCount; i++)
{
String propertyName = ShaderUtil.GetPropertyName(Shader, i);
ShaderUtil.ShaderPropertyType propertyType = ShaderUtil.GetPropertyType(Shader, i);
bool addAsNew = true;
foreach (var materialProperty in MaterialProperties)
{
if (materialProperty.Get().Name.Equals(propertyName))
{
if (MaterialPropertyTypeToShaderPropertyType(materialProperty.Get().GetType()).Equals(propertyType))
{
propertiesToAdd.Add(materialProperty);
addAsNew = false;
}
break;
}
}
if (addAsNew)
{
switch (propertyType)
{
case ShaderUtil.ShaderPropertyType.Float:
propertiesToAdd.Add(new MaterialPropertyWrapper(new MaterialFloatProperty(propertyName, 0.0f)));
break;
case ShaderUtil.ShaderPropertyType.Color:
propertiesToAdd.Add(new MaterialPropertyWrapper(new MaterialColorProperty(propertyName, Color.black)));
break;
case ShaderUtil.ShaderPropertyType.Vector:
propertiesToAdd.Add(new MaterialPropertyWrapper(new MaterialVectorProperty(propertyName, Vector4.zero)));
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
propertiesToAdd.Add(new MaterialPropertyWrapper(new MaterialTextureProperty(propertyName, null)));
break;
}
}
}
MaterialProperties = propertiesToAdd;
RefreshPropertyIds();
}
//Dynamically create a shaderproperty for each shader property in the actual shader target
public void AddProperties()
{
List <ShaderProperties> p = new List <ShaderProperties>();
//Check each of the properties in the actual shader target and create out ShaderProperties structure accordingly
for (int i = 0; i < ShaderUtil.GetPropertyCount(skf.shader); i++)
{
//Check for the type of the shader property index since there are some types we never want to change (ie vectors)
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(skf.shader, i);
//the true variable inside the shader target (ie _ZoomValue)
string trueName = ShaderUtil.GetPropertyName(skf.shader, i);
string displayName = string.Empty;
//Create a "clean" string of the shader property name (ie _ZoomValue to Zoom Value) that we'll use as the display name
for (int k = 0; k < trueName.Length; k++)
{
if (char.IsUpper(trueName[k]) && k != 1)
{
displayName += $" {trueName[k]}";
}
else
{
displayName += trueName[k];
}
}
ShaderProperties prop = new ShaderProperties();
//since we dont want to modify textures we'll skip all of these
if (type != ShaderUtil.ShaderPropertyType.TexEnv)
{
//Create our properties structure and add it to our list
prop = new ShaderProperties
{
_TrueName = trueName,
_Name = $"{displayName.Replace("_", "")} ({type.ToString()})",
_Strength = 0,
_Offset = 0,
_UseForKeyframing = false,
_LogValue = false,
_Frequency = 0,
_PropertyType = type,
_FilterRange = 0
};
p.Add(prop);
}
}
//Update the ShaderKeyFramers shaderproperties list with the list of structures we created in this method
skf.properties = p;
serializedObject.ApplyModifiedProperties();
}
/*
* private static string[] kShaderLevels = new string[]
* {
* "Fixed function",
* "SM1.x",
* "SM2.0",
* "SM3.0",
* "SM4.0",
* "SM5.0"
* };
*/
private static string GetPropertyType(Shader s, int index)
{
#pragma warning disable CS0436 // Type conflicts with imported type
ShaderUtil.ShaderPropertyType propertyType = ShaderUtil.GetPropertyType(s, index);
if (propertyType == ShaderUtil.ShaderPropertyType.TexEnv)
{
return(ShaderForgeInspector.kTextureTypes[(int)ShaderUtil.GetTexDim(s, index)]);
}
#pragma warning restore CS0436 // Type conflicts with imported type
return(ShaderForgeInspector.kPropertyTypes[(int)propertyType]);
}
// This function will look for all referenced lit material, and assign value from Lit to layered lit layers.
// This is based on the naming of the variables, i.E BaseColor will match BaseColor0, if a properties shouldn't be override
// put the name in the exclusionList below
static void SynchronizeLayerProperties(Material material, Material[] layers, int layerIndex)
{
Material layerMaterial = layers[layerIndex];
if (layerMaterial != null)
{
Shader layerShader = layerMaterial.shader;
int propertyCount = ShaderUtil.GetPropertyCount(layerShader);
for (int i = 0; i < propertyCount; ++i)
{
string propertyName = ShaderUtil.GetPropertyName(layerShader, i);
string layerPropertyName = propertyName + layerIndex;
if (material.HasProperty(layerPropertyName))
{
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(layerShader, i);
switch (type)
{
case ShaderUtil.ShaderPropertyType.Color:
{
material.SetColor(layerPropertyName, layerMaterial.GetColor(propertyName));
break;
}
case ShaderUtil.ShaderPropertyType.Float:
case ShaderUtil.ShaderPropertyType.Range:
{
material.SetFloat(layerPropertyName, layerMaterial.GetFloat(propertyName));
break;
}
case ShaderUtil.ShaderPropertyType.Vector:
{
material.SetVector(layerPropertyName, layerMaterial.GetVector(propertyName));
break;
}
case ShaderUtil.ShaderPropertyType.TexEnv:
{
material.SetTexture(layerPropertyName, layerMaterial.GetTexture(propertyName));
material.SetTextureOffset(layerPropertyName, layerMaterial.GetTextureOffset(propertyName));
material.SetTextureScale(layerPropertyName, layerMaterial.GetTextureScale(propertyName));
break;
}
}
}
}
}
}
private static string GetPropertyType(Shader s, int index)
{
ShaderUtil.ShaderPropertyType propertyType = ShaderUtil.GetPropertyType(s, index);
string result;
if (propertyType == ShaderUtil.ShaderPropertyType.TexEnv)
{
result = ShaderInspector.kTextureTypes[(int)ShaderUtil.GetTexDim(s, index)];
}
else
{
result = ShaderInspector.kPropertyTypes[(int)propertyType];
}
return(result);
}
public static void SerializeShaderProperty(Shader shader, int i, ByteBuffer buffer)
{
string description = ShaderUtil.GetPropertyDescription(shader, i);
string name = ShaderUtil.GetPropertyName(shader, i);
ShaderUtil.ShaderPropertyType propertyType = ShaderUtil.GetPropertyType(shader, i);
bool hidden = ShaderUtil.IsShaderPropertyHidden(shader, i);
buffer.AppendUnicodeString(description);
buffer.AppendUnicodeString(name);
buffer.Append((int)propertyType);
buffer.Append(hidden);
buffer.Append(ShaderUtil.GetRangeLimits(shader, i, 1));
buffer.Append(ShaderUtil.GetRangeLimits(shader, i, 2));
}
public override void onParse(WXMaterial wxbb_material)
{
Material material = this.m_material;
// 生成shader模板
Shader shader = m_material.shader;
WXEffect wxbb_effect = new WXEffect(shader);
this.dependenciesAdder(wxbb_effect);
if (shader == null)
{
Debug.LogErrorFormat("材质{0}缺少自定义shader", material.name);
return;
}
// 指定shader名字
SetEffect(wxbb_effect.Export(null));
for (int i = 0; i < ShaderUtil.GetPropertyCount(shader); i++)
{
string name = ShaderUtil.GetPropertyName(shader, i);
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(shader, i);
switch (type)
{
case ShaderUtil.ShaderPropertyType.Float:
case ShaderUtil.ShaderPropertyType.Range:
AddShaderParam(name, material.GetFloat(name));
break;
case ShaderUtil.ShaderPropertyType.Vector:
Vector4 v = material.GetVector(name);
AddShaderParam(name, new float[] { v.x, v.y, v.z, v.w });
break;
case ShaderUtil.ShaderPropertyType.Color:
AddShaderParam(name, material.GetColor(name), true);
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
AddTexture(name, name);
Vector4 st = material.GetVector(name + "_ST");
AddShaderParam(name + "_ST", new float[] { st.x, st.y, st.z, st.w });
break;
}
}
}
private static bool _ClearMat(Material mat, string path)
{
shaderValue.Clear();
Shader shader = mat.shader;
int count = ShaderUtil.GetPropertyCount(shader);
for (int i = 0; i < count; ++i)
{
ShaderValue sv = null;
string name = ShaderUtil.GetPropertyName(shader, i);
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(shader, i);
switch (type)
{
case ShaderUtil.ShaderPropertyType.Color:
sv = new ShaderColorValue(name, type, mat);
break;
case ShaderUtil.ShaderPropertyType.Vector:
sv = new ShaderVectorValue(name, type, mat);
break;
case ShaderUtil.ShaderPropertyType.Float:
sv = new ShaderFloatValue(name, type, mat);
break;
case ShaderUtil.ShaderPropertyType.Range:
sv = new ShaderFloatValue(name, type, mat);
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
sv = new ShaderTexValue(name, type, mat);
break;
}
shaderValue.Add(sv);
}
Material emptyMat = new Material(shader);
mat.CopyPropertiesFromMaterial(emptyMat);
UnityEngine.Object.DestroyImmediate(emptyMat);
for (int i = 0; i < shaderValue.Count; ++i)
{
ShaderValue sv = shaderValue[i];
sv.SetValue(mat);
}
mat.renderQueue = -1;
return(true);
}
static ShaderPropertyType ConvType(ShaderUtil.ShaderPropertyType src)
{
switch (src)
{
case ShaderUtil.ShaderPropertyType.TexEnv: return(ShaderPropertyType.TexEnv);
case ShaderUtil.ShaderPropertyType.Color: return(ShaderPropertyType.Color);
case ShaderUtil.ShaderPropertyType.Float: return(ShaderPropertyType.Float);
case ShaderUtil.ShaderPropertyType.Range: return(ShaderPropertyType.Range);
case ShaderUtil.ShaderPropertyType.Vector: return(ShaderPropertyType.Vector);
default: throw new NotImplementedException();
}
}
public ShaderMapping(Shader _shader, EditorWindow window)
{
sourceShader = _shader;
int propCount = ShaderUtil.GetPropertyCount(_shader);
sourceShaderProps = new ShaderProp[propCount];
for (int i = 0; i < propCount; i++)
{
string propName = ShaderUtil.GetPropertyName(_shader, i);
ShaderUtil.ShaderPropertyType propType = ShaderUtil.GetPropertyType(_shader, i);
sourceShaderProps[i] = new ShaderProp(ShaderUtil.GetPropertyName(_shader, i), ShaderUtil.GetPropertyType(_shader, i));
}
targetShader = null;
targetShaderProps = new Dictionary <ShaderUtil.ShaderPropertyType, List <ShaderProp> >();
propertyMapping = new Dictionary <ShaderProp, ShaderProp>();
show = new AnimBool(true);
show.valueChanged.AddListener(window.Repaint);
}
public UBER_MaterialProp[] GetMaterialProps(Material mat)
{
if (mat == null)
{
return(null);
}
int cnt = ShaderUtil.GetPropertyCount(mat.shader);
if (cnt == 0)
{
return(null);
}
UBER_MaterialProp[] props = new UBER_MaterialProp[cnt];
for (int i = 0; i < cnt; i++)
{
props[i] = new UBER_MaterialProp();
props[i].name = ShaderUtil.GetPropertyName(mat.shader, i);
ShaderUtil.ShaderPropertyType propType = ShaderUtil.GetPropertyType(mat.shader, i);
props[i].type = propType;
if (propType == ShaderUtil.ShaderPropertyType.Color)
{
props[i].colorValue = mat.GetColor(props[i].name);
}
else if (propType == ShaderUtil.ShaderPropertyType.Float || propType == ShaderUtil.ShaderPropertyType.Range)
{
props[i].floatValue = mat.GetFloat(props[i].name);
}
else if (ShaderUtil.GetPropertyType(mat.shader, i) == ShaderUtil.ShaderPropertyType.Vector)
{
props[i].vectorValue = mat.GetVector(props[i].name);
}
else if (ShaderUtil.GetPropertyType(mat.shader, i) == ShaderUtil.ShaderPropertyType.TexEnv)
{
props[i].textureValue = mat.GetTexture(props[i].name);
props[i].textureOffset = mat.GetTextureOffset(props[i].name);
props[i].textureScale = mat.GetTextureScale(props[i].name);
}
}
return(props);
}
private static RuntimeShaderInfo Create(Shader shader)
{
if (shader == null)
{
throw new System.ArgumentNullException("shader");
}
int propertyCount = ShaderUtil.GetPropertyCount(shader);
RuntimeShaderInfo shaderInfo = new RuntimeShaderInfo();
shaderInfo.Name = shader.name;
shaderInfo.PropertyCount = propertyCount;
shaderInfo.PropertyDescriptions = new string[propertyCount];
shaderInfo.PropertyNames = new string[propertyCount];
shaderInfo.PropertyRangeLimits = new RuntimeShaderInfo.RangeLimits[propertyCount];
shaderInfo.PropertyTexDims = new TextureDimension[propertyCount];
shaderInfo.PropertyTypes = new RTShaderPropertyType[propertyCount];
shaderInfo.IsHidden = new bool[propertyCount];
for (int i = 0; i < propertyCount; ++i)
{
shaderInfo.PropertyDescriptions[i] = ShaderUtil.GetPropertyDescription(shader, i);
shaderInfo.PropertyNames[i] = ShaderUtil.GetPropertyName(shader, i);
shaderInfo.PropertyRangeLimits[i] = new RuntimeShaderInfo.RangeLimits(
ShaderUtil.GetRangeLimits(shader, i, 0),
ShaderUtil.GetRangeLimits(shader, i, 1),
ShaderUtil.GetRangeLimits(shader, i, 2));
shaderInfo.PropertyTexDims[i] = ShaderUtil.GetTexDim(shader, i);
RTShaderPropertyType rtType = RTShaderPropertyType.Unknown;
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(shader, i);
if (m_typeToType.ContainsKey(type))
{
rtType = m_typeToType[type];
}
shaderInfo.PropertyTypes[i] = rtType;
shaderInfo.IsHidden[i] = ShaderUtil.IsShaderPropertyHidden(shader, i);
}
return(shaderInfo);
}
public static void GetMatTex(Material mat, List <Texture> lst)
{
Shader shader = mat.shader;
int count = ShaderUtil.GetPropertyCount(shader);
for (int i = 0; i < count; ++i)
{
string name = ShaderUtil.GetPropertyName(shader, i);
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(shader, i);
switch (type)
{
case ShaderUtil.ShaderPropertyType.TexEnv:
Texture tex = mat.GetTexture(name);
if (tex != null)
{
lst.Add(tex);
}
break;
}
}
}
private static ShaderUtil.ShaderPropertyType[] GetShaderPropertyFilter(ThemePropertyTypes shaderPropertyType)
{
ShaderUtil.ShaderPropertyType[] shaderTypes = null;
switch (shaderPropertyType)
{
case ThemePropertyTypes.Color:
shaderTypes = new ShaderUtil.ShaderPropertyType[] { ShaderUtil.ShaderPropertyType.Color };
break;
case ThemePropertyTypes.Texture:
shaderTypes = new ShaderUtil.ShaderPropertyType[] { ShaderUtil.ShaderPropertyType.TexEnv };
break;
case ThemePropertyTypes.ShaderFloat:
case ThemePropertyTypes.ShaderRange:
shaderTypes = new ShaderUtil.ShaderPropertyType[] { ShaderUtil.ShaderPropertyType.Float, ShaderUtil.ShaderPropertyType.Range };
break;
}
return(shaderTypes);
}
