private static string GetPropertyType(Shader s, int index)
{
UnityEditor.ShaderUtil.ShaderPropertyType propertyType = UnityEditor.ShaderUtil.GetPropertyType(s, index);
if (propertyType == UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv)
{
return(CustomShaderInspector.kTextureTypes[( int )UnityEditor.ShaderUtil.GetTexDim(s, index)]);
}
return(CustomShaderInspector.kPropertyTypes[( int )propertyType]);
}
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
{
IOUtils.Init();
Material mat = materialEditor.target as Material;
if (mat == null)
{
return;
}
m_instance = materialEditor;
if (!m_initialized)
{
Init();
m_initialized = true;
Undo.undoRedoPerformed += UndoRedoPerformed;
}
if (Event.current.type == EventType.Repaint &&
mat.HasProperty(IOUtils.DefaultASEDirtyCheckId) &&
mat.GetInt(IOUtils.DefaultASEDirtyCheckId) == 1)
{
mat.SetInt(IOUtils.DefaultASEDirtyCheckId, 0);
UIUtils.ForceUpdateFromMaterial();
//Event.current.Use();
}
if (materialEditor.isVisible)
{
GUILayout.BeginVertical();
{
GUILayout.Space(3);
if (GUILayout.Button("Open in Shader Editor"))
{
#if UNITY_2018_3_OR_NEWER
ASEPackageManagerHelper.SetupLateMaterial(mat);
#else
AmplifyShaderEditorWindow.LoadMaterialToASE(mat);
#endif
}
GUILayout.BeginHorizontal();
{
if (GUILayout.Button(CopyButtonStr))
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
Shader shader = mat.shader;
int propertyCount = UnityEditor.ShaderUtil.GetPropertyCount(shader);
string allProperties = string.Empty;
for (int i = 0; i < propertyCount; i++)
{
UnityEditor.ShaderUtil.ShaderPropertyType type = UnityEditor.ShaderUtil.GetPropertyType(shader, i);
string name = UnityEditor.ShaderUtil.GetPropertyName(shader, i);
string valueStr = string.Empty;
switch (type)
{
case UnityEditor.ShaderUtil.ShaderPropertyType.Color:
{
Color value = mat.GetColor(name);
valueStr = value.r.ToString() + IOUtils.VECTOR_SEPARATOR +
value.g.ToString() + IOUtils.VECTOR_SEPARATOR +
value.b.ToString() + IOUtils.VECTOR_SEPARATOR +
value.a.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Vector:
{
Vector4 value = mat.GetVector(name);
valueStr = value.x.ToString() + IOUtils.VECTOR_SEPARATOR +
value.y.ToString() + IOUtils.VECTOR_SEPARATOR +
value.z.ToString() + IOUtils.VECTOR_SEPARATOR +
value.w.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Float:
{
float value = mat.GetFloat(name);
valueStr = value.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Range:
{
float value = mat.GetFloat(name);
valueStr = value.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv:
{
Texture value = mat.GetTexture(name);
valueStr = AssetDatabase.GetAssetPath(value);
Vector2 offset = mat.GetTextureOffset(name);
Vector2 scale = mat.GetTextureScale(name);
valueStr += IOUtils.VECTOR_SEPARATOR + scale.x.ToString() +
IOUtils.VECTOR_SEPARATOR + scale.y.ToString() +
IOUtils.VECTOR_SEPARATOR + offset.x.ToString() +
IOUtils.VECTOR_SEPARATOR + offset.y.ToString();
}
break;
}
allProperties += name + IOUtils.FIELD_SEPARATOR + type + IOUtils.FIELD_SEPARATOR + valueStr;
if (i < (propertyCount - 1))
{
allProperties += IOUtils.LINE_TERMINATOR;
}
}
EditorPrefs.SetString(IOUtils.MAT_CLIPBOARD_ID, allProperties);
System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
}
if (GUILayout.Button(PasteButtonStr))
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
string propertiesStr = EditorPrefs.GetString(IOUtils.MAT_CLIPBOARD_ID, string.Empty);
if (!string.IsNullOrEmpty(propertiesStr))
{
string[] propertyArr = propertiesStr.Split(IOUtils.LINE_TERMINATOR);
bool validData = true;
try
{
for (int i = 0; i < propertyArr.Length; i++)
{
string[] valuesArr = propertyArr[i].Split(IOUtils.FIELD_SEPARATOR);
if (valuesArr.Length != 3)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else if (mat.HasProperty(valuesArr[0]))
{
UnityEditor.ShaderUtil.ShaderPropertyType type = (UnityEditor.ShaderUtil.ShaderPropertyType)Enum.Parse(typeof(UnityEditor.ShaderUtil.ShaderPropertyType), valuesArr[1]);
switch (type)
{
case UnityEditor.ShaderUtil.ShaderPropertyType.Color:
{
string[] colorVals = valuesArr[2].Split(IOUtils.VECTOR_SEPARATOR);
if (colorVals.Length != 4)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else
{
mat.SetColor(valuesArr[0], new Color(Convert.ToSingle(colorVals[0]),
Convert.ToSingle(colorVals[1]),
Convert.ToSingle(colorVals[2]),
Convert.ToSingle(colorVals[3])));
}
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Vector:
{
string[] vectorVals = valuesArr[2].Split(IOUtils.VECTOR_SEPARATOR);
if (vectorVals.Length != 4)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else
{
mat.SetVector(valuesArr[0], new Vector4(Convert.ToSingle(vectorVals[0]),
Convert.ToSingle(vectorVals[1]),
Convert.ToSingle(vectorVals[2]),
Convert.ToSingle(vectorVals[3])));
}
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Float:
{
mat.SetFloat(valuesArr[0], Convert.ToSingle(valuesArr[2]));
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Range:
{
mat.SetFloat(valuesArr[0], Convert.ToSingle(valuesArr[2]));
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv:
{
string[] texVals = valuesArr[2].Split(IOUtils.VECTOR_SEPARATOR);
if (texVals.Length != 5)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else
{
mat.SetTexture(valuesArr[0], AssetDatabase.LoadAssetAtPath <Texture>(texVals[0]));
mat.SetTextureScale(valuesArr[0], new Vector2(Convert.ToSingle(texVals[1]), Convert.ToSingle(texVals[2])));
mat.SetTextureOffset(valuesArr[0], new Vector2(Convert.ToSingle(texVals[3]), Convert.ToSingle(texVals[4])));
}
}
break;
}
}
}
}
catch (Exception e)
{
Debug.LogException(e);
validData = false;
}
if (validData)
{
materialEditor.PropertiesChanged();
UIUtils.CopyValuesFromMaterial(mat);
}
else
{
EditorPrefs.SetString(IOUtils.MAT_CLIPBOARD_ID, string.Empty);
}
}
System.Threading.Thread.CurrentThread.CurrentCulture = System.Threading.Thread.CurrentThread.CurrentUICulture;
}
}
GUILayout.EndHorizontal();
GUILayout.Space(5);
}
GUILayout.EndVertical();
}
EditorGUI.BeginChangeCheck();
//base.OnGUI( materialEditor, properties );
// Draw custom properties instead of calling BASE to use single line texture properties
materialEditor.SetDefaultGUIWidths();
if (m_infoField == null)
{
m_infoField = typeof(MaterialEditor).GetField("m_InfoMessage", BindingFlags.Instance | BindingFlags.NonPublic);
}
string info = m_infoField.GetValue(materialEditor) as string;
if (!string.IsNullOrEmpty(info))
{
EditorGUILayout.HelpBox(info, MessageType.Info);
}
else
{
GUIUtility.GetControlID("EditorTextField".GetHashCode(), FocusType.Passive, new Rect(0f, 0f, 0f, 0f));
}
for (int i = 0; i < properties.Length; i++)
{
if ((properties[i].flags & (MaterialProperty.PropFlags.HideInInspector | MaterialProperty.PropFlags.PerRendererData)) == MaterialProperty.PropFlags.None)
{
// Removed no scale offset one line texture property for consistency :( sad face
//if( ( properties[ i ].flags & MaterialProperty.PropFlags.NoScaleOffset ) == MaterialProperty.PropFlags.NoScaleOffset )
//{
// object obj = MaterialPropertyHandlerEx.GetHandler( mat.shader, properties[ i ].name );
// if( obj != null )
// {
// float height = MaterialPropertyHandlerEx.GetPropertyHeight( obj, properties[ i ], properties[ i ].displayName, materialEditor );
// //Rect rect = (Rect)materialEditor.GetType().InvokeMember( "GetPropertyRect", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod, null, materialEditor, new object[] { properties[ i ], properties[ i ].displayName, true } );
// Rect rect = EditorGUILayout.GetControlRect( true, height, EditorStyles.layerMaskField );
// MaterialPropertyHandlerEx.OnGUI( obj, ref rect, properties[ i ], new GUIContent( properties[ i ].displayName ), materialEditor );
// if( MaterialPropertyHandlerEx.PropertyDrawer( obj ) != null )
// continue;
// rect = EditorGUILayout.GetControlRect( true, height, EditorStyles.layerMaskField );
// materialEditor.TexturePropertyMiniThumbnail( rect, properties[ i ], properties[ i ].displayName, string.Empty );
// }
// else
// {
// materialEditor.TexturePropertySingleLine( new GUIContent( properties[ i ].displayName ), properties[ i ] );
// }
//}
//else
//{
float propertyHeight = materialEditor.GetPropertyHeight(properties[i], properties[i].displayName);
Rect controlRect = EditorGUILayout.GetControlRect(true, propertyHeight, EditorStyles.layerMaskField, new GUILayoutOption[0]);
materialEditor.ShaderProperty(controlRect, properties[i], properties[i].displayName);
//}
}
}
EditorGUILayout.Space();
materialEditor.RenderQueueField();
#if UNITY_5_6_OR_NEWER
materialEditor.EnableInstancingField();
#endif
#if UNITY_5_6_2 || UNITY_5_6_3 || UNITY_5_6_4 || UNITY_2017_1_OR_NEWER
materialEditor.DoubleSidedGIField();
#endif
materialEditor.LightmapEmissionProperty();
if (m_refreshOnUndo || EditorGUI.EndChangeCheck())
{
m_refreshOnUndo = false;
string isEmissive = mat.GetTag("IsEmissive", false, "false");
if (isEmissive.Equals("true"))
{
mat.globalIlluminationFlags &= (MaterialGlobalIlluminationFlags)3;
}
else
{
mat.globalIlluminationFlags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
UIUtils.CopyValuesFromMaterial(mat);
}
if (materialEditor.RequiresConstantRepaint() && m_lastRenderedTime + 0.032999999821186066 < EditorApplication.timeSinceStartup)
{
this.m_lastRenderedTime = EditorApplication.timeSinceStartup;
materialEditor.Repaint();
}
}
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
{
IOUtils.Init();
Material mat = materialEditor.target as Material;
if (mat == null)
{
return;
}
m_instance = materialEditor;
if (Event.current.type == EventType.repaint &&
mat.HasProperty(IOUtils.DefaultASEDirtyCheckId) &&
mat.GetInt(IOUtils.DefaultASEDirtyCheckId) == 1)
{
mat.SetInt(IOUtils.DefaultASEDirtyCheckId, 0);
UIUtils.ForceUpdateFromMaterial();
#if !UNITY_5_5_OR_NEWER
Event.current.Use();
#endif
}
if (materialEditor.isVisible)
{
GUILayout.BeginVertical();
{
GUILayout.Space(3);
if (GUILayout.Button("Open in Shader Editor"))
{
AmplifyShaderEditorWindow.LoadMaterialToASE(mat);
}
GUILayout.BeginHorizontal();
{
if (GUILayout.Button(CopyButtonStr))
{
Shader shader = mat.shader;
int propertyCount = UnityEditor.ShaderUtil.GetPropertyCount(shader);
string allProperties = string.Empty;
for (int i = 0; i < propertyCount; i++)
{
UnityEditor.ShaderUtil.ShaderPropertyType type = UnityEditor.ShaderUtil.GetPropertyType(shader, i);
string name = UnityEditor.ShaderUtil.GetPropertyName(shader, i);
string valueStr = string.Empty;
switch (type)
{
case UnityEditor.ShaderUtil.ShaderPropertyType.Color:
{
Color value = mat.GetColor(name);
valueStr = value.r.ToString() + IOUtils.VECTOR_SEPARATOR +
value.g.ToString() + IOUtils.VECTOR_SEPARATOR +
value.b.ToString() + IOUtils.VECTOR_SEPARATOR +
value.a.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Vector:
{
Vector4 value = mat.GetVector(name);
valueStr = value.x.ToString() + IOUtils.VECTOR_SEPARATOR +
value.y.ToString() + IOUtils.VECTOR_SEPARATOR +
value.z.ToString() + IOUtils.VECTOR_SEPARATOR +
value.w.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Float:
{
float value = mat.GetFloat(name);
valueStr = value.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Range:
{
float value = mat.GetFloat(name);
valueStr = value.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv:
{
Texture value = mat.GetTexture(name);
valueStr = AssetDatabase.GetAssetPath(value);
}
break;
}
allProperties += name + IOUtils.FIELD_SEPARATOR + type + IOUtils.FIELD_SEPARATOR + valueStr;
if (i < (propertyCount - 1))
{
allProperties += IOUtils.LINE_TERMINATOR;
}
}
EditorPrefs.SetString(IOUtils.MAT_CLIPBOARD_ID, allProperties);
}
if (GUILayout.Button(PasteButtonStr))
{
string propertiesStr = EditorPrefs.GetString(IOUtils.MAT_CLIPBOARD_ID, string.Empty);
if (!string.IsNullOrEmpty(propertiesStr))
{
string[] propertyArr = propertiesStr.Split(IOUtils.LINE_TERMINATOR);
bool validData = true;
try
{
for (int i = 0; i < propertyArr.Length; i++)
{
string[] valuesArr = propertyArr[i].Split(IOUtils.FIELD_SEPARATOR);
if (valuesArr.Length != 3)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else if (mat.HasProperty(valuesArr[0]))
{
UnityEditor.ShaderUtil.ShaderPropertyType type = (UnityEditor.ShaderUtil.ShaderPropertyType)Enum.Parse(typeof(UnityEditor.ShaderUtil.ShaderPropertyType), valuesArr[1]);
switch (type)
{
case UnityEditor.ShaderUtil.ShaderPropertyType.Color:
{
string[] colorVals = valuesArr[2].Split(IOUtils.VECTOR_SEPARATOR);
if (colorVals.Length != 4)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else
{
mat.SetColor(valuesArr[0], new Color(Convert.ToSingle(colorVals[0]),
Convert.ToSingle(colorVals[1]),
Convert.ToSingle(colorVals[2]),
Convert.ToSingle(colorVals[3])));
}
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Vector:
{
string[] vectorVals = valuesArr[2].Split(IOUtils.VECTOR_SEPARATOR);
if (vectorVals.Length != 4)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else
{
mat.SetVector(valuesArr[0], new Vector4(Convert.ToSingle(vectorVals[0]),
Convert.ToSingle(vectorVals[1]),
Convert.ToSingle(vectorVals[2]),
Convert.ToSingle(vectorVals[3])));
}
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Float:
{
mat.SetFloat(valuesArr[0], Convert.ToSingle(valuesArr[2]));
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Range:
{
mat.SetFloat(valuesArr[0], Convert.ToSingle(valuesArr[2]));
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv:
{
mat.SetTexture(valuesArr[0], AssetDatabase.LoadAssetAtPath <Texture>(valuesArr[2]));
}
break;
}
}
}
}
catch (Exception e)
{
Debug.LogError(e);
validData = false;
}
if (validData)
{
materialEditor.PropertiesChanged();
UIUtils.CopyValuesFromMaterial(mat);
}
else
{
EditorPrefs.SetString(IOUtils.MAT_CLIPBOARD_ID, string.Empty);
}
}
}
}
GUILayout.EndHorizontal();
GUILayout.Space(5);
}
GUILayout.EndVertical();
}
EditorGUI.BeginChangeCheck();
base.OnGUI(materialEditor, properties);
materialEditor.LightmapEmissionProperty();
if (EditorGUI.EndChangeCheck())
{
//mat.globalIlluminationFlags &= ( MaterialGlobalIlluminationFlags ) 3;
string isEmissive = mat.GetTag("IsEmissive", false, "false");
if (isEmissive.Equals("true"))
{
mat.globalIlluminationFlags &= ( MaterialGlobalIlluminationFlags )3;
}
else
{
mat.globalIlluminationFlags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
UIUtils.CopyValuesFromMaterial(mat);
}
}
public void GetShaderInfoFromShaderAsset(ref string propertiesDecl, ref string propertiesSet)
{
bool fetchInitialInfo = false;
if (m_currentShader == null)
{
Material mat = Selection.activeObject as Material;
if (mat != null)
{
m_currentShader = mat.shader;
}
else
{
m_currentShader = Selection.activeObject as Shader;
}
fetchInitialInfo = true;
}
if (m_currentShader != null)
{
if (fetchInitialInfo)
{
GetInitialInfo(m_currentShader);
}
if (m_dummyMaterial == null)
{
m_dummyMaterial = new Material(m_currentShader);
}
else
{
m_dummyMaterial.shader = m_currentShader;
}
int propertyCount = UnityEditor.ShaderUtil.GetPropertyCount(m_currentShader);
//string allProperties = string.Empty;
int validIds = 0;
for (int i = 0; i < propertyCount; i++)
{
UnityEditor.ShaderUtil.ShaderPropertyType type = UnityEditor.ShaderUtil.GetPropertyType(m_currentShader, i);
string name = UnityEditor.ShaderUtil.GetPropertyName(m_currentShader, i);
//string description = UnityEditor.ShaderUtil.GetPropertyDescription( m_currentShader, i );
if (m_excludedProperties.ContainsKey(name))
{
continue;
}
string defaultValue = string.Empty;
bool nullPointerCheck = false;
switch (type)
{
case UnityEditor.ShaderUtil.ShaderPropertyType.Color:
{
Color value = m_dummyMaterial.GetColor(name);
defaultValue = string.Format("value = new Color({0}f,{1}f,{2}f,{3}f)", value.r, value.g, value.b, value.a);
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Vector:
{
Vector4 value = m_dummyMaterial.GetVector(name);
defaultValue = string.Format("value = new Vector4({0}f,{1}f,{2}f,{3}f)", value.x, value.y, value.z, value.w);
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Float:
{
float value = m_dummyMaterial.GetFloat(name);
defaultValue = "value = " + value + "f";
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Range:
{
float value = m_dummyMaterial.GetFloat(name);
defaultValue = "value = " + value + "f";
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv:
{
nullPointerCheck = true;
}
break;
}
propertiesDecl += string.Format(PPSPropertyDecFormat, string.Empty, m_tooltips[validIds].Tooltip, ShaderPropertyToPPSType[type], name, defaultValue);
propertiesSet += string.Format(nullPointerCheck ? PPSPropertySetNullPointerCheckFormat : PPSPropertySetFormat, ShaderPropertyToPPSSet[type], name);
validIds++;
}
}
}
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
{
if (!m_initialized)
{
m_initialized = true;
m_linkStyle = new GUIStyle(GUIStyle.none);
m_linkStyle.alignment = TextAnchor.UpperCenter;
m_lableStyle = new GUIStyle(GUI.skin.label);
m_lableStyle.wordWrap = true;
m_lableStyle.alignment = TextAnchor.MiddleLeft;
m_defaultImage = AssetDatabase.LoadAssetAtPath <Texture2D>(AssetDatabase.GUIDToAssetPath("19890ee0a82f7a643b9077407a6da3db"));
m_imageRatio = (float)m_defaultImage.height / (float)m_defaultImage.width;
m_maxheight = m_defaultImage.height;
m_textLink = new GUIStyle(GUI.skin.label);
m_textLink.normal.textColor = Color.white;
m_textLink.alignment = TextAnchor.MiddleCenter;
m_textLink.fontSize = 9;
}
m_materialEditor = materialEditor;
Material material = materialEditor.target as Material;
if (m_fetchedImage != null)
{
m_button.image = m_fetchedImage;
m_imageRatio = (float)m_fetchedImage.height / (float)m_fetchedImage.width;
m_maxheight = m_fetchedImage.height;
}
else
{
m_button.image = m_defaultImage;
m_imageRatio = 0.31818f;
m_maxheight = 140;
if (!m_imageLoaded)
{
m_imageLoaded = true;
EditorApplication.update += EditorUpdateFetchInfo;
coroutine = StartRequest(m_jsonURL);
}
}
EditorGUILayout.BeginVertical("ObjectFieldThumb");
{
m_currheight = Mathf.Min(m_maxheight, (EditorGUIUtility.currentViewWidth - 30) * m_imageRatio);
Rect buttonRect = EditorGUILayout.GetControlRect(false, m_currheight);
EditorGUIUtility.AddCursorRect(buttonRect, MouseCursor.Link);
if (GUI.Button(buttonRect, m_button, m_linkStyle))
{
Help.BrowseURL(m_info.affiliateLink);
}
GUILayout.BeginHorizontal();
GUILayout.Label(m_info.message, m_lableStyle /*, GUILayout.MinHeight(40)*/);
GUILayout.FlexibleSpace();
GUILayout.BeginVertical();
if (GUILayout.Button("Learn More", GUILayout.Height(25)))
{
Help.BrowseURL(m_info.affiliateLink);
}
Color cache = GUI.color;
GUI.color = EditorGUIUtility.isProSkin ? LinkColorInPro : LinkColorInPersonal;
if (GUILayout.Button("Affiliate Link", m_textLink))
{
AboutAffiliate.Init();
}
GUI.color = cache;
GUILayout.EndVertical();
GUILayout.EndHorizontal();
}
EditorGUILayout.EndVertical();
#if AMPLIFY_SHADER_EDITOR
if (Event.current.type == EventType.Repaint &&
material.HasProperty(IOUtils.DefaultASEDirtyCheckId) &&
material.GetInt(IOUtils.DefaultASEDirtyCheckId) == 1)
{
material.SetInt(IOUtils.DefaultASEDirtyCheckId, 0);
UIUtils.ForceUpdateFromMaterial();
#if !UNITY_5_5_OR_NEWER
Event.current.Use();
#endif
}
if (GUILayout.Button("Open in Shader Editor"))
{
AmplifyShaderEditorWindow.LoadMaterialToASE(material);
}
GUILayout.BeginHorizontal();
{
if (GUILayout.Button("Copy Values"))
{
Shader shader = material.shader;
int propertyCount = UnityEditor.ShaderUtil.GetPropertyCount(shader);
string allProperties = string.Empty;
for (int i = 0; i < propertyCount; i++)
{
UnityEditor.ShaderUtil.ShaderPropertyType type = UnityEditor.ShaderUtil.GetPropertyType(shader, i);
string name = UnityEditor.ShaderUtil.GetPropertyName(shader, i);
string valueStr = string.Empty;
switch (type)
{
case UnityEditor.ShaderUtil.ShaderPropertyType.Color:
{
Color value = material.GetColor(name);
valueStr = value.r.ToString() + IOUtils.VECTOR_SEPARATOR +
value.g.ToString() + IOUtils.VECTOR_SEPARATOR +
value.b.ToString() + IOUtils.VECTOR_SEPARATOR +
value.a.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Vector:
{
Vector4 value = material.GetVector(name);
valueStr = value.x.ToString() + IOUtils.VECTOR_SEPARATOR +
value.y.ToString() + IOUtils.VECTOR_SEPARATOR +
value.z.ToString() + IOUtils.VECTOR_SEPARATOR +
value.w.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Float:
{
float value = material.GetFloat(name);
valueStr = value.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Range:
{
float value = material.GetFloat(name);
valueStr = value.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv:
{
Texture value = material.GetTexture(name);
valueStr = AssetDatabase.GetAssetPath(value);
}
break;
}
allProperties += name + IOUtils.FIELD_SEPARATOR + type + IOUtils.FIELD_SEPARATOR + valueStr;
if (i < (propertyCount - 1))
{
allProperties += IOUtils.LINE_TERMINATOR;
}
}
EditorPrefs.SetString(IOUtils.MAT_CLIPBOARD_ID, allProperties);
}
if (GUILayout.Button("Paste Values"))
{
string propertiesStr = EditorPrefs.GetString(IOUtils.MAT_CLIPBOARD_ID, string.Empty);
if (!string.IsNullOrEmpty(propertiesStr))
{
string[] propertyArr = propertiesStr.Split(IOUtils.LINE_TERMINATOR);
bool validData = true;
try
{
for (int i = 0; i < propertyArr.Length; i++)
{
string[] valuesArr = propertyArr[i].Split(IOUtils.FIELD_SEPARATOR);
if (valuesArr.Length != 3)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else if (material.HasProperty(valuesArr[0]))
{
UnityEditor.ShaderUtil.ShaderPropertyType type = (UnityEditor.ShaderUtil.ShaderPropertyType)Enum.Parse(typeof(UnityEditor.ShaderUtil.ShaderPropertyType), valuesArr[1]);
switch (type)
{
case UnityEditor.ShaderUtil.ShaderPropertyType.Color:
{
string[] colorVals = valuesArr[2].Split(IOUtils.VECTOR_SEPARATOR);
if (colorVals.Length != 4)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else
{
material.SetColor(valuesArr[0], new Color(Convert.ToSingle(colorVals[0]),
Convert.ToSingle(colorVals[1]),
Convert.ToSingle(colorVals[2]),
Convert.ToSingle(colorVals[3])));
}
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Vector:
{
string[] vectorVals = valuesArr[2].Split(IOUtils.VECTOR_SEPARATOR);
if (vectorVals.Length != 4)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else
{
material.SetVector(valuesArr[0], new Vector4(Convert.ToSingle(vectorVals[0]),
Convert.ToSingle(vectorVals[1]),
Convert.ToSingle(vectorVals[2]),
Convert.ToSingle(vectorVals[3])));
}
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Float:
{
material.SetFloat(valuesArr[0], Convert.ToSingle(valuesArr[2]));
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Range:
{
material.SetFloat(valuesArr[0], Convert.ToSingle(valuesArr[2]));
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv:
{
material.SetTexture(valuesArr[0], AssetDatabase.LoadAssetAtPath <Texture>(valuesArr[2]));
}
break;
}
}
}
}
catch (Exception e)
{
Debug.LogException(e);
validData = false;
}
if (validData)
{
materialEditor.PropertiesChanged();
UIUtils.CopyValuesFromMaterial(material);
}
else
{
EditorPrefs.SetString(IOUtils.MAT_CLIPBOARD_ID, string.Empty);
}
}
}
}
GUILayout.EndHorizontal();
GUILayout.Space(5);
#endif
#if AMPLIFY_SHADER_EDITOR
EditorGUI.BeginChangeCheck();
ShaderPropertiesGUI(material, properties);
if (EditorGUI.EndChangeCheck())
{
UIUtils.CopyValuesFromMaterial(material);
}
#else
ShaderPropertiesGUI(material, properties);
#endif
}
/// <summary>
/// Collect all meshes, materials and textures underneath the specified object and serialize them into the DataNode.
/// </summary>
static public void SerializeSharedResources(this GameObject go, DataNode node, bool includeInactive = false)
{
mFullSerialization = true;
MeshFilter[] filters = go.GetComponentsInChildren <MeshFilter>(includeInactive);
MeshRenderer[] rens = go.GetComponentsInChildren <MeshRenderer>(includeInactive);
SkinnedMeshRenderer[] sks = go.GetComponentsInChildren <SkinnedMeshRenderer>(includeInactive);
List <Material> materials = new List <Material>();
List <Mesh> meshes = new List <Mesh>();
foreach (MeshFilter f in filters)
{
Mesh m = f.sharedMesh;
if (!meshes.Contains(m))
{
meshes.Add(m);
}
}
foreach (SkinnedMeshRenderer sk in sks)
{
Mesh m = sk.sharedMesh;
if (!meshes.Contains(m))
{
meshes.Add(m);
}
Material[] mats = sk.sharedMaterials;
foreach (Material mt in mats)
{
if (!materials.Contains(mt))
{
materials.Add(mt);
}
}
}
foreach (MeshRenderer r in rens)
{
Material[] mats = r.sharedMaterials;
foreach (Material m in mats)
{
if (!materials.Contains(m))
{
materials.Add(m);
}
}
}
if (materials.size == 0 && meshes.size == 0)
{
return;
}
#if UNITY_EDITOR
List <Texture> textures = new List <Texture>();
for (int i = 0; i < materials.size; ++i)
{
Material mat = materials[i];
Shader s = mat.shader;
if (s == null)
{
continue;
}
string matPath = UnityTools.LocateResource(mat);
if (!string.IsNullOrEmpty(matPath))
{
continue;
}
int props = UnityEditor.ShaderUtil.GetPropertyCount(s);
for (int b = 0; b < props; ++b)
{
string propName = UnityEditor.ShaderUtil.GetPropertyName(s, b);
UnityEditor.ShaderUtil.ShaderPropertyType type = UnityEditor.ShaderUtil.GetPropertyType(s, b);
if (type != UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv)
{
continue;
}
Texture tex = mat.GetTexture(propName);
if (tex != null && !textures.Contains(tex))
{
textures.Add(tex);
}
}
}
for (int i = 0; i < textures.size; ++i)
{
Texture tex = textures[i];
tex.Serialize(node.AddChild("Texture", tex.GetInstanceID()));
}
#endif
for (int i = 0; i < materials.size; ++i)
{
Material mat = materials[i];
mat.Serialize(node.AddChild("Material", mat.GetInstanceID()), false);
}
for (int i = 0; i < meshes.size; ++i)
{
Mesh mesh = meshes[i];
mesh.Serialize(node.AddChild("Mesh", mesh.GetInstanceID()));
}
}
/// <summary>
/// Serialize the specified material into its DataNode format.
/// </summary>
static public void Serialize(this Material mat, DataNode node, bool serializeTextures)
{
if (!mFullSerialization)
{
return;
}
node.AddChild("name", mat.name);
string path = UnityTools.LocateResource(mat);
if (!string.IsNullOrEmpty(path))
{
node.AddChild("path", path);
return;
}
Shader s = mat.shader;
if (s != null)
{
node.AddChild("shader", s.name);
#if UNITY_EDITOR
int props = UnityEditor.ShaderUtil.GetPropertyCount(s);
for (int b = 0; b < props; ++b)
{
string propName = UnityEditor.ShaderUtil.GetPropertyName(s, b);
UnityEditor.ShaderUtil.ShaderPropertyType type = UnityEditor.ShaderUtil.GetPropertyType(s, b);
if (type == UnityEditor.ShaderUtil.ShaderPropertyType.Color)
{
node.AddChild(propName, mat.GetColor(propName));
}
else if (type == UnityEditor.ShaderUtil.ShaderPropertyType.Vector)
{
node.AddChild(propName, mat.GetVector(propName));
}
else if (type == UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv)
{
Texture tex = mat.GetTexture(propName);
if (tex != null)
{
DataNode sub = new DataNode(propName, tex.GetInstanceID());
if (serializeTextures)
{
tex.Serialize(sub);
}
sub.AddChild("offset", mat.GetTextureOffset(propName));
sub.AddChild("scale", mat.GetTextureScale(propName));
node.children.Add(sub);
}
}
else
{
node.AddChild(propName, mat.GetFloat(propName));
}
}
#endif
}
}
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
{
IOUtils.Init();
Material mat = materialEditor.target as Material;
if (mat == null)
{
return;
}
m_instance = materialEditor;
if (Event.current.type == EventType.Repaint &&
mat.HasProperty(IOUtils.DefaultASEDirtyCheckId) &&
mat.GetInt(IOUtils.DefaultASEDirtyCheckId) == 1)
{
mat.SetInt(IOUtils.DefaultASEDirtyCheckId, 0);
UIUtils.ForceUpdateFromMaterial();
#if !UNITY_5_5_OR_NEWER
Event.current.Use();
#endif
}
if (materialEditor.isVisible)
{
GUILayout.BeginVertical();
{
GUILayout.Space(3);
if (GUILayout.Button("Open in Shader Editor"))
{
AmplifyShaderEditorWindow.LoadMaterialToASE(mat);
}
GUILayout.BeginHorizontal();
{
if (GUILayout.Button(CopyButtonStr))
{
Shader shader = mat.shader;
int propertyCount = UnityEditor.ShaderUtil.GetPropertyCount(shader);
string allProperties = string.Empty;
for (int i = 0; i < propertyCount; i++)
{
UnityEditor.ShaderUtil.ShaderPropertyType type = UnityEditor.ShaderUtil.GetPropertyType(shader, i);
string name = UnityEditor.ShaderUtil.GetPropertyName(shader, i);
string valueStr = string.Empty;
switch (type)
{
case UnityEditor.ShaderUtil.ShaderPropertyType.Color:
{
Color value = mat.GetColor(name);
valueStr = value.r.ToString() + IOUtils.VECTOR_SEPARATOR +
value.g.ToString() + IOUtils.VECTOR_SEPARATOR +
value.b.ToString() + IOUtils.VECTOR_SEPARATOR +
value.a.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Vector:
{
Vector4 value = mat.GetVector(name);
valueStr = value.x.ToString() + IOUtils.VECTOR_SEPARATOR +
value.y.ToString() + IOUtils.VECTOR_SEPARATOR +
value.z.ToString() + IOUtils.VECTOR_SEPARATOR +
value.w.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Float:
{
float value = mat.GetFloat(name);
valueStr = value.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Range:
{
float value = mat.GetFloat(name);
valueStr = value.ToString();
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv:
{
Texture value = mat.GetTexture(name);
valueStr = AssetDatabase.GetAssetPath(value);
}
break;
}
allProperties += name + IOUtils.FIELD_SEPARATOR + type + IOUtils.FIELD_SEPARATOR + valueStr;
if (i < (propertyCount - 1))
{
allProperties += IOUtils.LINE_TERMINATOR;
}
}
EditorPrefs.SetString(IOUtils.MAT_CLIPBOARD_ID, allProperties);
}
if (GUILayout.Button(PasteButtonStr))
{
string propertiesStr = EditorPrefs.GetString(IOUtils.MAT_CLIPBOARD_ID, string.Empty);
if (!string.IsNullOrEmpty(propertiesStr))
{
string[] propertyArr = propertiesStr.Split(IOUtils.LINE_TERMINATOR);
bool validData = true;
try
{
for (int i = 0; i < propertyArr.Length; i++)
{
string[] valuesArr = propertyArr[i].Split(IOUtils.FIELD_SEPARATOR);
if (valuesArr.Length != 3)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else if (mat.HasProperty(valuesArr[0]))
{
UnityEditor.ShaderUtil.ShaderPropertyType type = (UnityEditor.ShaderUtil.ShaderPropertyType)Enum.Parse(typeof(UnityEditor.ShaderUtil.ShaderPropertyType), valuesArr[1]);
switch (type)
{
case UnityEditor.ShaderUtil.ShaderPropertyType.Color:
{
string[] colorVals = valuesArr[2].Split(IOUtils.VECTOR_SEPARATOR);
if (colorVals.Length != 4)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else
{
mat.SetColor(valuesArr[0], new Color(Convert.ToSingle(colorVals[0]),
Convert.ToSingle(colorVals[1]),
Convert.ToSingle(colorVals[2]),
Convert.ToSingle(colorVals[3])));
}
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Vector:
{
string[] vectorVals = valuesArr[2].Split(IOUtils.VECTOR_SEPARATOR);
if (vectorVals.Length != 4)
{
Debug.LogWarning("Material clipboard data is corrupted");
validData = false;
break;
}
else
{
mat.SetVector(valuesArr[0], new Vector4(Convert.ToSingle(vectorVals[0]),
Convert.ToSingle(vectorVals[1]),
Convert.ToSingle(vectorVals[2]),
Convert.ToSingle(vectorVals[3])));
}
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Float:
{
mat.SetFloat(valuesArr[0], Convert.ToSingle(valuesArr[2]));
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.Range:
{
mat.SetFloat(valuesArr[0], Convert.ToSingle(valuesArr[2]));
}
break;
case UnityEditor.ShaderUtil.ShaderPropertyType.TexEnv:
{
mat.SetTexture(valuesArr[0], AssetDatabase.LoadAssetAtPath <Texture>(valuesArr[2]));
}
break;
}
}
}
}
catch (Exception e)
{
Debug.LogException(e);
validData = false;
}
if (validData)
{
materialEditor.PropertiesChanged();
UIUtils.CopyValuesFromMaterial(mat);
}
else
{
EditorPrefs.SetString(IOUtils.MAT_CLIPBOARD_ID, string.Empty);
}
}
}
}
GUILayout.EndHorizontal();
GUILayout.Space(5);
}
GUILayout.EndVertical();
}
EditorGUI.BeginChangeCheck();
//base.OnGUI( materialEditor, properties );
// Draw custom properties instead of calling BASE to use single line texture properties
materialEditor.SetDefaultGUIWidths();
FieldInfo field = typeof(MaterialEditor).GetField("m_InfoMessage", BindingFlags.Instance | BindingFlags.NonPublic);
string infoField = field.GetValue(materialEditor) as string;
if (!string.IsNullOrEmpty(infoField))
{
EditorGUILayout.HelpBox(infoField, MessageType.Info);
}
else
{
GUIUtility.GetControlID("EditorTextField".GetHashCode(), FocusType.Passive, new Rect(0f, 0f, 0f, 0f));
}
for (int i = 0; i < properties.Length; i++)
{
if ((properties[i].flags & (MaterialProperty.PropFlags.HideInInspector | MaterialProperty.PropFlags.PerRendererData)) == MaterialProperty.PropFlags.None)
{
if ((properties[i].flags & MaterialProperty.PropFlags.NoScaleOffset) == MaterialProperty.PropFlags.NoScaleOffset)
{
materialEditor.TexturePropertySingleLine(new GUIContent(properties[i].displayName), properties[i]);
}
else
{
float propertyHeight = materialEditor.GetPropertyHeight(properties[i], properties[i].displayName);
Rect controlRect = EditorGUILayout.GetControlRect(true, propertyHeight, EditorStyles.layerMaskField, new GUILayoutOption[0]);
materialEditor.ShaderProperty(controlRect, properties[i], properties[i].displayName);
}
}
}
#if UNITY_5_5_2 || UNITY_5_5_3 || UNITY_5_5_4 || UNITY_5_5_5 || UNITY_5_6_OR_NEWER
EditorGUILayout.Space();
EditorGUILayout.Space();
materialEditor.RenderQueueField();
#endif
#if UNITY_5_6_OR_NEWER
materialEditor.EnableInstancingField();
#endif
#if UNITY_5_6_2 || UNITY_5_6_3 || UNITY_5_6_4 || UNITY_2017_1_OR_NEWER
materialEditor.DoubleSidedGIField();
#endif
materialEditor.LightmapEmissionProperty();
if (EditorGUI.EndChangeCheck())
{
//mat.globalIlluminationFlags &= ( MaterialGlobalIlluminationFlags ) 3;
string isEmissive = mat.GetTag("IsEmissive", false, "false");
if (isEmissive.Equals("true"))
{
mat.globalIlluminationFlags &= ( MaterialGlobalIlluminationFlags )3;
}
else
{
mat.globalIlluminationFlags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
UIUtils.CopyValuesFromMaterial(mat);
}
}
