public static void HandleAssignments(Material material, List <FXTextureAssigner.RenderTextureAssignment> assignments)
{
var fxTextureSlots = new List <FXTextureSlot>();
if (material)
{
var shader = material.shader;
for (int i = 0; i < ShaderUtil.GetPropertyCount(shader); i++)
{
var isFxTexture = ShaderUtil.GetPropertyType(shader, i) == ShaderUtil.ShaderPropertyType.TexEnv &&
FXMaterialHelper.GetFXTextureType(ShaderUtil.GetPropertyDescription(shader, i)) != null;
if (isFxTexture)
{
var match = Regex.Match(ShaderUtil.GetPropertyDescription(shader, i), @"(.*)\(\w*\).*", RegexOptions.IgnoreCase);
fxTextureSlots.Add(new FXTextureSlot()
{
Name = ShaderUtil.GetPropertyName(shader, i),
Description = match.Groups[1].Value.Trim()
});
}
}
}
var currentSlots = assignments.Select(a => a.TextureName);
var slotsToRemove = currentSlots.Except(fxTextureSlots.Select(slot => slot.Name)).ToArray();
var slotsToAdd = fxTextureSlots.Where(slot => !currentSlots.Any(s => s == slot.Name)).ToArray();
foreach (var toRemove in slotsToRemove)
{
assignments.Remove(assignments.First(a => a.TextureName == toRemove));
}
foreach (var toAdd in slotsToAdd)
{
assignments.Add(new FXTextureAssigner.RenderTextureAssignment()
{
TextureName = toAdd.Name,
TextureDescription = toAdd.Description
});
}
foreach (var assignment in assignments)
{
assignment.RenderTexture = (FXRenderTexture)EditorGUILayout.ObjectField(assignment.TextureDescription, assignment.RenderTexture, typeof(FXRenderTexture), false);
}
}
public override void OnInspectorGUI()
{
Debug.Log("==OnInspectorGUI== ");
base.OnInspectorGUI();
Material material = target as Material;
Shader shader = material.shader;
for (int i = 0; i < ShaderUtil.GetPropertyCount(shader); i++)
{
if (ShaderUtil.GetPropertyType(shader, i) != ShaderUtil.ShaderPropertyType.TexEnv)
{
continue;
}
//属性
string name = ShaderUtil.GetPropertyName(shader, i);
//文本值
string label = ShaderUtil.GetPropertyDescription(shader, i);
TextureDimension desiredTexdim = ShaderUtil.GetTexDim(shader, i);
System.Type t;
switch (desiredTexdim)
{
case TextureDimension.Tex2D:
t = typeof(Texture);
//Debug.Log (" Tex2D ");
Texture t1 = material.GetTexture(name);
break;
case TextureDimension.Cube:
t = typeof(Cubemap);
//Debug.Log (" Cube ");
break;
case TextureDimension.Tex3D:
t = typeof(Texture3D);
//Debug.Log (" Tex3D ");
break;
case TextureDimension.Tex2DArray:
t = typeof(Texture);
//Debug.Log (" Tex2DArray ");
break;
default:
t = null;
break;
}
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
base.OnPreviewGUI(r, background);
Material targetMat = target as Material; //我们正在编辑的材质
Shader shader = targetMat.shader;
string label = ShaderUtil.GetPropertyDescription(shader, 0);
string propertyName = ShaderUtil.GetPropertyName(shader, 0);
Texture tex = targetMat.GetTexture(propertyName);
if (tex != null)
{
EditorGUILayout.LabelField("" + tex.name + " height:" + tex.height + "," + "width:" + tex.width);
}
}
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));
}
private void InitShader(ShaderLerpInfo shaderInfo, string shaderName)
{
shaderInfo.ShaderName = shaderName;
shaderInfo.PropsToLerp = new List <ShaderPropLerpInfo>();
var shader = Shader.Find(shaderName);
var props = ShaderUtil.GetPropertyCount(shader);
for (int i = 0; i < props; i++)
{
var propName = ShaderUtil.GetPropertyName(shader, i);
var propDesc = ShaderUtil.GetPropertyDescription(shader, i);
var type = ShaderUtil.GetPropertyType(shader, i);
if (!new[] { ShaderUtil.ShaderPropertyType.Color, ShaderUtil.ShaderPropertyType.Float, ShaderUtil.ShaderPropertyType.Range }.Any(s => type == s))
{
continue;
}
ShaderType shaderType;
switch (type)
{
case ShaderUtil.ShaderPropertyType.Color:
shaderType = ShaderType.Color;
break;
case ShaderUtil.ShaderPropertyType.Float:
shaderType = ShaderType.Float;
break;
case ShaderUtil.ShaderPropertyType.Range:
shaderType = ShaderType.Range;
break;
default:
throw new ArgumentOutOfRangeException();
}
shaderInfo.PropsToLerp.Add(new ShaderPropLerpInfo()
{
PropName = propName,
PropDesc = propDesc,
PropType = shaderType,
OnlyLerpAlpha = true,
LerpTo = 0
});
}
}
//When an object is selected
void OnEnable()
{
//First, we gotta get the sprite or image component on the thing
//Jesus Christ, Jesse, your keyboard is infuriating
Sprite_CustomProperties comp = serializedObject.targetObject as Sprite_CustomProperties;
SpriteRenderer sprite = comp.GetComponent <SpriteRenderer>();
Image image = comp.GetComponent <Image>();
CanvasRenderer canv = comp.GetComponent <CanvasRenderer>();
if (sprite != null)
{
m = sprite.material;
sprite.GetPropertyBlock(block);
isCanvas = false;
comp.IsCanvasRenderer = true;
}
else if (image != null)
{
isCanvas = true;
m = image.material;
comp.IsCanvasRenderer = true;
}
s = m.shader;
numProperties = ShaderUtil.GetPropertyCount(s);
materialProperties = new List <MProperty>();
for (int i = 0; i < numProperties; i++)
{
MProperty newProp = new MProperty();
newProp.name = ShaderUtil.GetPropertyName(s, i);
newProp.description = ShaderUtil.GetPropertyDescription(s, i);
//newProp.type = ShaderUtil.GetPropertyType(s, i);
newProp.hidden = ShaderUtil.IsShaderPropertyHidden(s, i);
//These are hardcoded values that Unity already takes care of for us
if (!(newProp.name == "_MainTex" || newProp.name == "_Color"))
{
materialProperties.Add(newProp);
}
}
}
private void PopulatePropertiesFromShader()
{
if ( _Shader != null )
{
int propertyCount = ShaderUtil.GetPropertyCount( _Shader );
if ( propertyCount > 0 )
{
for ( int i = 0; i < propertyCount; i++ )
{
string name = ShaderUtil.GetPropertyName( _Shader, i );
if ( !_CastedTarget.Properties.Any( x => x.Name == name ) )
{
string desc = ShaderUtil.GetPropertyDescription( _Shader, i );
MaterialProperty newProp;
switch ( ShaderUtil.GetPropertyType( _Shader, i ) )
{
case SPT.Color:
newProp = new MaterialProperty( name, desc, _Material.GetColor( name ) );
break;
case SPT.TexEnv:
newProp = new MaterialProperty( name, desc, _Material.GetTexture( name ) );
break;
case SPT.Vector:
newProp = new MaterialProperty( name, desc, _Material.GetVector( name ) );
break;
case SPT.Float:
case SPT.Range:
default:
newProp = new MaterialProperty( name, desc, _Material.GetFloat( name ) );
break;
}
_CastedTarget.Properties.Add( newProp );
}
}
}
}
}
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);
}
/// <summary>
/// Shaderから指定のnameのプロパティの description を取得する。
/// </summary>
/// <param name="shader"></param>
/// <param name="name"></param>
/// <returns></returns>
private static string getPropertyDescription(Shader shader, string name)
{
#if UNITY_2019_1_OR_NEWER
var idx = shader.FindPropertyIndex(name);
if (0 <= idx)
{
return(shader.GetPropertyDescription(idx));
}
return(null);
#else
for (int idx = ShaderUtil.GetPropertyCount(shader) - 1; 0 <= idx; idx--)
{
if (name == ShaderUtil.GetPropertyName(shader, idx))
{
return(ShaderUtil.GetPropertyDescription(shader, idx));
}
}
return(null);
#endif
}
// 更新 Shader 数据
void UpdateShader()
{
if (material)
{
if (_material.shader != _shader)
{
_shader = _material.shader;
_propertyIndexInMenu = -2;
if (_shader)
{
_propertyIndexes.Clear();
_propertyCount = ShaderUtil.GetPropertyCount(_shader);
for (int i = 0; i < _propertyCount; i++)
{
if (!ShaderUtil.IsShaderPropertyHidden(_shader, i) && ShaderUtil.GetPropertyType(_shader, i) == propertyType)
{
_propertyIndexes.Add(i);
}
}
_propertyCount = _propertyIndexes.Count;
if (_propertyCount > 0)
{
_propertyNames = new string[_propertyCount];
_propertyDescriptions = new string[_propertyCount];
for (int i = 0; i < _propertyCount; i++)
{
_propertyNames[i] = ShaderUtil.GetPropertyName(_shader, _propertyIndexes[i]);
_propertyDescriptions[i] = string.Format("{0} ({1})",
ShaderUtil.GetPropertyDescription(_shader, _propertyIndexes[i]),
_propertyNames[i]);
}
}
}
}
}
else _shader = null;
}
bool DrawShaderPropertyOptions(SerializedProperty pLayer)
{
SerializedProperty shaderProperty = pLayer.FindPropertyRelative("mShaderProperty");
SerializedProperty materialID = pLayer.FindPropertyRelative("mMaterialID");
List <string> texturePropertyNames = new List <string>();
List <string> textureDescriptions = new List <string>();
Shader shader = mMaterialMotion.GetComponent <Renderer>().sharedMaterials[materialID.intValue].shader;
for (int i = 0; i < ShaderUtil.GetPropertyCount(shader); ++i)
{
switch (ShaderUtil.GetPropertyType(shader, i))
{
case ShaderUtil.ShaderPropertyType.TexEnv:
case ShaderUtil.ShaderPropertyType.Float:
case ShaderUtil.ShaderPropertyType.Color:
case ShaderUtil.ShaderPropertyType.Range:
textureDescriptions.Add(ShaderUtil.GetPropertyDescription(shader, i));
texturePropertyNames.Add(ShaderUtil.GetPropertyName(shader, i));
break;
}
}
if (texturePropertyNames.Count == 0)
{
EditorGUILayout.HelpBox("Shader does not have any valid Inputs (Texture, Float, Color)", MessageType.Info);
return(true);
}
int index = texturePropertyNames.FindIndex(x => x.Equals(shaderProperty.stringValue));
if (index == -1)
{
index = 0;
}
index = EditorGUILayout.Popup("Shader Property:", index, textureDescriptions.ToArray());
shaderProperty.stringValue = texturePropertyNames[index];
pLayer.FindPropertyRelative("mMotionProperty").enumValueIndex = (int)ShaderUtil.GetPropertyType(shader, index);
return(false);
}
private void ShaderPropertyImpl(Shader shader, int propertyIndex, FeatureToggle currentToggle)
{
string propertyDescription = ShaderUtil.GetPropertyDescription(shader, propertyIndex);
if (currentToggle == null)
{
for (int i = 0; i < Toggles.Count; i++)
{
if (Regex.IsMatch(propertyDescription, Toggles[i].InspectorPropertyHideTag, RegexOptions.IgnoreCase))
{
return;
}
}
}
else if (!Regex.IsMatch(propertyDescription, currentToggle.InspectorPropertyHideTag, RegexOptions.IgnoreCase))
{
return;
}
MaterialProperty materialProperty = GetMaterialProperty(targets, propertyIndex);
ShaderProperty(materialProperty, materialProperty.displayName);
}
public List <MaterialProperty> GetShaderProperties(Material material)
{
if (cache.ContainsKey(material.shader.name))
{
return(cache[material.shader.name]);
}
var list = new List <MaterialProperty>();
Shader s = material.shader;
int count = ShaderUtil.GetPropertyCount(s);
for (int i = 0; i < count; i++)
{
list.Add(new MaterialProperty()
{
type = ShaderUtil.GetPropertyType(s, i),
description = ShaderUtil.GetPropertyDescription(s, i),
name = ShaderUtil.GetPropertyName(s, i)
});
}
cache[material.shader.name] = list;
return(list);
}
// This runs once for every property in our shader.
private void ShaderPropertyImpl(Shader shader, int propertyIndex, FeatureToggle currentToggle)
{
string propertyDescription = ShaderUtil.GetPropertyDescription(shader, propertyIndex);
// If current toggle is null, we only want to show properties that aren't already "owned" by a toggle,
// so if it is owned by another toggle, then return.
if (currentToggle == null)
{
for (int i = 0; i < Toggles.Count; i++)
{
if (Regex.IsMatch(propertyDescription, Toggles[i].InspectorPropertyHideTag, RegexOptions.IgnoreCase))
{
return;
}
}
}
// Only draw if we the current property is owned by the current toggle.
else if (!Regex.IsMatch(propertyDescription, currentToggle.InspectorPropertyHideTag, RegexOptions.IgnoreCase))
{
return;
}
// If we've gotten to this point, draw the shader property regulairly.
ShaderProperty(shader, propertyIndex);
}
public static List <TexEnv> GetTexEnvs(Shader shader)
{
texEnvNames.Clear();
if (shader != null)
{
var count = ShaderUtil.GetPropertyCount(shader);
for (var i = 0; i < count; i++)
{
if (ShaderUtil.GetPropertyType(shader, i) == ShaderUtil.ShaderPropertyType.TexEnv)
{
var texEnv = default(TexEnv);
texEnv.Name = ShaderUtil.GetPropertyName(shader, i);
texEnv.Desc = ShaderUtil.GetPropertyDescription(shader, i);
texEnvNames.Add(texEnv);
}
}
}
return(texEnvNames);
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
var drawingPosition = position;
drawingPosition.height = EditorGUIUtility.singleLineHeight;
var shaderProperty = property.FindPropertyRelative("shader");
var currentShaderReference = shaderProperty.objectReferenceValue as Shader;
var prefix = "Hidden/EPO/Fill/";
var fillLabel = currentShaderReference == null ? "none" : currentShaderReference.name.Substring(prefix.Length);
if (shaderProperty.hasMultipleDifferentValues)
{
fillLabel = "-";
}
if (EditorGUI.DropdownButton(position, new GUIContent("Fill type: " + fillLabel), FocusType.Passive))
{
var menu = new GenericMenu();
menu.AddItem(new GUIContent("none"), currentShaderReference == null && !shaderProperty.hasMultipleDifferentValues, () =>
{
shaderProperty.objectReferenceValue = null;
shaderProperty.serializedObject.ApplyModifiedProperties();
});
var shaders = AssetDatabase.FindAssets("t:Shader");
foreach (var shader in shaders)
{
var loadedShader = AssetDatabase.LoadAssetAtPath(AssetDatabase.GUIDToAssetPath(shader), typeof(Shader)) as Shader;
if (!loadedShader.name.StartsWith(prefix))
{
continue;
}
menu.AddItem(new GUIContent(loadedShader.name.Substring(prefix.Length)), loadedShader == shaderProperty.objectReferenceValue && !shaderProperty.hasMultipleDifferentValues, () =>
{
shaderProperty.objectReferenceValue = loadedShader;
shaderProperty.serializedObject.ApplyModifiedProperties();
});
}
menu.ShowAsContext();
}
if (shaderProperty.hasMultipleDifferentValues)
{
return;
}
if (currentShaderReference != null)
{
position.x += EditorGUIUtility.singleLineHeight;
position.width -= EditorGUIUtility.singleLineHeight;
var properties = new Dictionary <string, SerializedProperty>();
var serializedProperties = property.FindPropertyRelative("serializedProperties");
for (var index = 0; index < serializedProperties.arraySize; index++)
{
var subProperty = serializedProperties.GetArrayElementAtIndex(index);
var propertyName = subProperty.FindPropertyRelative("PropertyName");
var propertyValue = subProperty.FindPropertyRelative("Property");
if (propertyName == null || propertyValue == null)
{
break;
}
properties.Add(propertyName.stringValue, propertyValue);
}
var fillParametersPosition = position;
for (var index = 0; index < ShaderUtil.GetPropertyCount(currentShaderReference); index++)
{
var propertyName = ShaderUtil.GetPropertyName(currentShaderReference, index);
if (!propertyName.StartsWith("_Public"))
{
continue;
}
fillParametersPosition.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
SerializedProperty currentProperty;
if (!properties.TryGetValue(propertyName, out currentProperty))
{
serializedProperties.InsertArrayElementAtIndex(serializedProperties.arraySize);
currentProperty = serializedProperties.GetArrayElementAtIndex(serializedProperties.arraySize - 1);
currentProperty.FindPropertyRelative("PropertyName").stringValue = propertyName;
currentProperty = currentProperty.FindPropertyRelative("Property");
var tempMaterial = new Material(currentShaderReference);
switch (ShaderUtil.GetPropertyType(currentShaderReference, index))
{
case ShaderUtil.ShaderPropertyType.Color:
currentProperty.FindPropertyRelative("ColorValue").colorValue = tempMaterial.GetColor(propertyName);
break;
case ShaderUtil.ShaderPropertyType.Vector:
currentProperty.FindPropertyRelative("VectorValue").vector4Value = tempMaterial.GetVector(propertyName);
break;
case ShaderUtil.ShaderPropertyType.Float:
currentProperty.FindPropertyRelative("FloatValue").floatValue = tempMaterial.GetFloat(propertyName);
break;
case ShaderUtil.ShaderPropertyType.Range:
currentProperty.FindPropertyRelative("FloatValue").floatValue = tempMaterial.GetFloat(propertyName);
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
currentProperty.FindPropertyRelative("TextureValue").objectReferenceValue = tempMaterial.GetTexture(propertyName);
break;
}
GameObject.DestroyImmediate(tempMaterial);
properties.Add(propertyName, currentProperty);
}
if (currentProperty == null)
{
continue;
}
var content = new GUIContent(ShaderUtil.GetPropertyDescription(currentShaderReference, index));
switch (ShaderUtil.GetPropertyType(currentShaderReference, index))
{
case ShaderUtil.ShaderPropertyType.Color:
var colorProperty = currentProperty.FindPropertyRelative("ColorValue");
colorProperty.colorValue = EditorGUI.ColorField(fillParametersPosition, content, colorProperty.colorValue, true, true, true);
break;
case ShaderUtil.ShaderPropertyType.Vector:
var vectorProperty = currentProperty.FindPropertyRelative("VectorValue");
vectorProperty.vector4Value = EditorGUI.Vector4Field(fillParametersPosition, content, vectorProperty.vector4Value);
break;
case ShaderUtil.ShaderPropertyType.Float:
EditorGUI.PropertyField(fillParametersPosition, currentProperty.FindPropertyRelative("FloatValue"), content);
break;
case ShaderUtil.ShaderPropertyType.Range:
var floatProperty = currentProperty.FindPropertyRelative("FloatValue");
floatProperty.floatValue = EditorGUI.Slider(fillParametersPosition, content, floatProperty.floatValue,
ShaderUtil.GetRangeLimits(currentShaderReference, index, 1),
ShaderUtil.GetRangeLimits(currentShaderReference, index, 2));
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
EditorGUI.PropertyField(fillParametersPosition, currentProperty.FindPropertyRelative("TextureValue"), content);
break;
}
currentProperty.FindPropertyRelative("PropertyType").intValue = (int)ShaderUtil.GetPropertyType(currentShaderReference, index);
}
}
}
private void ShaderPropertyImpl(Shader shader, int propertyIndex)
{
Material myMat = target as Material;
Material[] mats = new Material[1] {
myMat
};
MaterialProperty aProp = MaterialEditor.GetMaterialProperty(mats, propertyIndex);
GUIStyle boldFoldoutStyle = new GUIStyle(EditorStyles.foldout);
boldFoldoutStyle.fontStyle = FontStyle.Bold;
Color c;
int i = propertyIndex;
bool separator_flag = false;
string label = ShaderUtil.GetPropertyDescription(shader, i);
if (label.IndexOf("<") >= 0)
{
label = label.Substring(1);
separator_flag = true;
}
string propertyName = ShaderUtil.GetPropertyName(shader, i);
bool adjustementFlag = false;
if (ShaderUtil.GetPropertyType(shader, i) == ShaderUtil.ShaderPropertyType.Float)
{
if (propertyName == "BlockStart")
{
adjustementFlag = true;
EditorGUILayout.BeginVertical("box");
c = GUI.color;
GUI.color = new Color(0.8f, 1, 0.8f);
GUILayout.BeginHorizontal();
GUILayout.Space(12);
propBlockAvailable = IsAvailable(ref label);
if (propBlockAvailable)
{
bool newVal = EditorGUILayout.Foldout(VolumeGrassMaterialInspector.blocks[i], label, boldFoldoutStyle);
if (VolumeGrassMaterialInspector.blocks[i] != newVal)
{
VolumeGrassMaterialInspector.blocks[i] = newVal;
EditorUtility.SetDirty(target);
}
}
else
{
EditorGUILayout.LabelField(label + " (switched off)");
}
unfolded = VolumeGrassMaterialInspector.blocks[i];
GUILayout.EndHorizontal();
GUI.color = c;
GUILayout.BeginHorizontal();
GUILayout.Space(10);
GUILayout.BeginVertical();
}
else if (propertyName == "BlockEnd")
{
adjustementFlag = true;
unfolded = true;
propBlockAvailable = true;
GUILayout.EndVertical();
GUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
GUILayout.Space(3);
}
}
if (!unfolded || !propBlockAvailable)
{
return;
}
if (separator_flag)
{
GUILayout.Space(8);
}
switch (ShaderUtil.GetPropertyType(shader, i))
{
case ShaderUtil.ShaderPropertyType.Range: // float ranges
{
GUILayout.BeginHorizontal();
RangeProperty(aProp, label);
GUILayout.EndHorizontal();
break;
}
case ShaderUtil.ShaderPropertyType.Float: // floats
{
if (!adjustementFlag)
{
FloatProperty(aProp, label);
}
break;
}
case ShaderUtil.ShaderPropertyType.Color: // colors
{
ColorProperty(aProp, label);
break;
}
case ShaderUtil.ShaderPropertyType.TexEnv: // textures
{
TextureProperty(aProp, label, false);
GUILayout.Space(6);
break;
}
case ShaderUtil.ShaderPropertyType.Vector: // vectors
{
VectorProperty(aProp, label);
break;
}
default:
{
GUILayout.Label("(unknown prop type for " + label + " ): " + ShaderUtil.GetPropertyType(shader, i));
break;
}
}
}
private void ShowShaderPropertys(Shader s, Material m)
{
string propertyName = string.Empty;
EditorGUI.BeginChangeCheck();
for (int i = 0; i < ShaderUtil.GetPropertyCount(s); i++)
{
if (!ShaderUtil.IsShaderPropertyHidden(s, i))
{
EditorGUILayout.BeginHorizontal();
propertyName = ShaderUtil.GetPropertyName(s, i);
MaterialProperty materialProperty = MaterialEditor.GetMaterialProperty(new UnityEngine.Object[] { m }, propertyName);
EditorGUILayout.LabelField(ShaderUtil.GetPropertyDescription(s, i), GUILayout.Width(150));
switch (ShaderUtil.GetPropertyType(s, i))
{
case ShaderUtil.ShaderPropertyType.Color:
Color c = EditorGUILayout.ColorField(m.GetColor(propertyName));
m.SetColor(propertyName, c);
break;
case ShaderUtil.ShaderPropertyType.Float:
float f = EditorGUILayout.FloatField(m.GetFloat(propertyName));
m.SetFloat(propertyName, f);
break;
case ShaderUtil.ShaderPropertyType.Range:
float min = ShaderUtil.GetRangeLimits(s, i, 1);
float max = ShaderUtil.GetRangeLimits(s, i, 2);
float r = EditorGUILayout.Slider(m.GetFloat(propertyName), min, max);
m.SetFloat(propertyName, r);
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
EditorGUILayout.BeginVertical();
Texture2D tex = (Texture2D)EditorGUILayout.ObjectField(m.GetTexture(propertyName), typeof(Texture2D), false);
Vector2 texOffset = EditorGUILayout.Vector2Field("TextureOffset", m.GetTextureOffset(propertyName));
Vector2 texScale = EditorGUILayout.Vector2Field("TextureOffset", m.GetTextureScale(propertyName));
EditorGUILayout.EndVertical();
m.SetTexture(propertyName, tex);
m.SetTextureOffset(propertyName, texOffset);
m.SetTextureScale(propertyName, texScale);
break;
case ShaderUtil.ShaderPropertyType.Vector:
Vector4 v = EditorGUILayout.Vector4Field("", m.GetVector(propertyName));
m.SetVector(propertyName, v);
break;
}
EditorGUILayout.EndHorizontal();
}
}
if (EditorGUI.EndChangeCheck())
{
serializedObject.ApplyModifiedProperties();
}
}
void DrawProperty(int materialCount)
{
var rect = EditorGUILayout.GetControlRect();
rect = EditorGUI.PrefixLabel(rect, EditorGUIKit.TempContent("Property"));
if (!string.IsNullOrEmpty(target.propertyName))
{
_builder.Append(target.propertyName);
_builder.Append(" (");
_builder.Append(target._propertyType);
_builder.Append(')');
}
if (GUI.Button(rect, _builder.ToString(), EditorStyles.layerMaskField))
{
var properties = new HashSet<Property>();
var menu = new GenericMenu();
for (int i = 0; i < materialCount; i++)
{
if (target.IsMaterialSelected(i) && _materials[i] && _materials[i].shader)
{
var shader = _materials[i].shader;
int count = ShaderUtil.GetPropertyCount(shader);
for (int idx = 0; idx < count; idx++)
{
if (!ShaderUtil.IsShaderPropertyHidden(shader, idx))
{
var prop = new Property
{
name = ShaderUtil.GetPropertyName(shader, idx),
type = ShaderUtil.GetPropertyType(shader, idx)
};
if (properties.Contains(prop)) continue;
properties.Add(prop);
string description = ShaderUtil.GetPropertyDescription(shader, idx);
if (prop.type == ShaderUtil.ShaderPropertyType.TexEnv)
{
prop.name += "_ST";
prop.type = ShaderUtil.ShaderPropertyType.Vector;
description += " Scale and Offest";
}
_builder.Clear();
_builder.Append(prop.name);
_builder.Append(" (\"");
_builder.Append(description);
_builder.Append("\", ");
_builder.Append(prop.type);
_builder.Append(')');
menu.AddItem(new GUIContent(_builder.ToString()),
target._propertyName == prop.name && target._propertyType == (Type)(int)prop.type,
() =>
{
Undo.RecordObject(target, "Select Property");
Type oldType = target.propertyType;
target.SetProperty(prop.name, (Type)(int)prop.type);
if (oldType != target.propertyType)
{
if (target.propertyType == Type.Color)
target.from = target.to = Color.white;
if (target.propertyType == Type.Float || target.propertyType == Type.Range)
target.from.x = target.to.x = 1f;
if (target.propertyType == Type.Vector)
{
if (prop.name.EndsWith("_ST"))
target.from = target.to = new Vector4(1, 1, 0, 0);
else
target.from = target.to = new Vector4(1, 1, 1, 1);
}
}
});
_builder.Clear();
}
}
}
}
if (properties.Count == 0) menu.AddItem(new GUIContent("(No Valid Property)"), false, () => { });
menu.DropDown(rect);
}
_builder.Clear();
}
void OnGUI() {
// Initialize objects
if (IconLoader == null) IconLoader = new IconLoader();
if (BGTex == null) {
BGTex = new Texture2D(1, 1);
BGTex.hideFlags = HideFlags.HideAndDontSave;
BGTex.SetPixel(0, 0, BGColor);
BGTex.Apply();
}
if (VertexStyle == null) {
VertexStyle = MakeStyle(Color.cyan, 0f);
FaceStyle = MakeStyle(Color.red, 0f);
ShadowStyle = MakeStyle(Color.black, 1f);
}
// Total canvas
Canvas = new Rect(0f, 0f, position.width * 4 * Zoom, position.height * 4 * Zoom);
// Scroll view
Rect scrollViewRect = new Rect(0, 0, position.width, position.height);
ScrollPoint = GUI.BeginScrollView(scrollViewRect, ScrollPoint, Canvas);
bool needsRepaint = false;
// Zoom with the mouse wheel
if (Event.current.type == EventType.ScrollWheel) {
Zoom += -Event.current.delta.y / 50;
if (Zoom < 0.1f) Zoom = 0.1f;
if (Zoom > 1f) Zoom = 1f;
needsRepaint = true;
Event.current.Use();
}
// Draw background
GUI.DrawTexture(new Rect(ScrollPoint.x, ScrollPoint.y, scrollViewRect.width, scrollViewRect.height), BGTex);
// Texture Inputs
GameObject go = Selection.activeObject as GameObject;
List<string> texInputsList = new List<string>();
texInputsList.Add("-");
Texture texPreview = null;
if (go != null) {
Renderer renderer = go.GetComponent<MeshRenderer>();
if (renderer != null) {
Material mat = renderer.sharedMaterial;
if (mat != null) {
for (int p = 0; p < ShaderUtil.GetPropertyCount(mat.shader); p++) {
if (ShaderUtil.GetPropertyType(mat.shader, p) == ShaderUtil.ShaderPropertyType.TexEnv) {
if (TexInput > 0 && TexInput == texInputsList.Count) {
texPreview = mat.GetTexture(ShaderUtil.GetPropertyName(mat.shader, p));
}
texInputsList.Add(ShaderUtil.GetPropertyDescription(mat.shader, p));
}
}
}
}
}
// Draw UV Canvas
Rect uvCanvas = new Rect(CanvasMargin, CanvasMarginTop, position.width * 4 * Zoom - CanvasMargin * 2, position.height * 4 * Zoom - (CanvasMarginTop + CanvasMargin));
if (texPreview) {
GUI.DrawTexture(uvCanvas, texPreview);
} else {
Handles.color = UVBorderColor;
Handles.DrawPolyLine(new Vector3[] {
new Vector3(uvCanvas.x, uvCanvas.y),
new Vector3(uvCanvas.x + uvCanvas.width, uvCanvas.y),
new Vector3(uvCanvas.x + uvCanvas.width, uvCanvas.y + uvCanvas.height),
new Vector3(uvCanvas.x, uvCanvas.height + uvCanvas.y),
new Vector3(uvCanvas.x, uvCanvas.y)
});
}
// UI
UVSet = EditorGUI.Popup(new Rect(10f, 12f, 100f, 30f), UVSet, new string[] { "uv0", "uv1" });
DisplayVertices = GUI.Toggle(new Rect(120f, 10f, 30f, 20f), DisplayVertices, IconLoader.Icons["vertex"], "button");
DisplayVertexIndices = GUI.Toggle(new Rect(155f, 10f, 30f, 20f), DisplayVertexIndices, IconLoader.Icons["vertexIndex"], "button");
DisplayEdges = GUI.Toggle(new Rect(190f, 10f, 30f, 20f), DisplayEdges, IconLoader.Icons["face"], "button");
DisplayFaces = GUI.Toggle(new Rect(225f, 10f, 30f, 20f), DisplayFaces, IconLoader.Icons["faceIndex"], "button");
TexInput = EditorGUI.Popup(new Rect(260f, 12f, 100f, 30f), TexInput, texInputsList.ToArray());
// Mesh data
if (go != null) {
var meshFilter = go.GetComponent<MeshFilter>();
if (meshFilter != null) {
Mesh mesh = meshFilter.sharedMesh;
Vector2[] uvSet = UVSet == 0 ? mesh.uv : mesh.uv2;
// Triangles
for (int i = 0; i < mesh.triangles.Length; i += 3) {
if (uvSet.Length == 0) {
break;
}
Vector3[] verts = new Vector3[3];
for (int n = 0; n < 3; n++) {
verts[n] = new Vector3(
uvCanvas.x + uvSet[mesh.triangles[i + n]].x * uvCanvas.width,
uvCanvas.y + (1 - uvSet[mesh.triangles[i + n]].y) * uvCanvas.height,
0f);
}
// Draw edges
if (DisplayEdges) {
Handles.color = Color.white;
Handles.DrawPolyLine(new Vector3[] { verts[0], verts[1], verts[2], verts[0] });
}
// Draw face indices
if (DisplayFaces) {
Handles.color = Color.red;
Vector3 mid = (verts[0] + verts[1] + verts[2]) / 3;
mid.y -= 10f;
DrawLabel(mid.x, mid.y, (i / 3).ToString(), FaceStyle);
}
}
// Vertices
for (int i = 0; i < uvSet.Length; i++) {
Vector2 uv = uvSet[i];
Vector3 point = new Vector3(uvCanvas.width * uv.x + uvCanvas.x, uvCanvas.height * (1 - uv.y) + uvCanvas.y, 0);
// Draw vertex indices
if (DisplayVertexIndices) {
DrawLabel(point.x, point.y, i.ToString(), VertexStyle);
}
// Draw vertices
if (DisplayVertices) {
float thickness = 2f;
Handles.color = Color.cyan;
Handles.DrawSolidRectangleWithOutline(new Vector3[] {
new Vector3(point.x - thickness, point.y - thickness, 0),
new Vector3(point.x - thickness, point.y + thickness, 0),
new Vector3(point.x + thickness, point.y + thickness, 0),
new Vector3(point.x + thickness, point.y - thickness, 0)
}, Color.white, Color.white);
}
}
}
}
// Handle left mouse button events
if (Event.current.button == 0) {
// MouseDown
if (Event.current.type == EventType.MouseDown && !_isDragging) {
_isDragging = true;
}
// MouseDrag
if (Event.current.type == EventType.MouseDrag && _isDragging) {
if (Event.current.delta.magnitude > 0) {
ScrollPoint.x += -Event.current.delta.x;
ScrollPoint.y += -Event.current.delta.y;
needsRepaint = true;
}
}
// MouseUp
if (Event.current.type == EventType.MouseUp) {
_isDragging = false;
}
} // Left mouse down/drag/up
// Right Click
if (Event.current.button == 1 && Event.current.type == EventType.MouseUp) {
var menu = new GenericMenu();
menu.AddItem(new GUIContent("WIP"), false, MenuAction, null);
menu.ShowAsContext();
}
if (needsRepaint) {
Repaint();
}
GUI.EndScrollView();
} // OnGUI
public override sealed void OnInspectorGUI()
{
base.OnInspectorGUI();
serializedObject.Update();
EditorGUILayout.PropertyField(refMaterial, refMaterialLabel);
if (refMaterial.objectReferenceValue == null)
{
EditorGUILayout.PropertyField(renderer);
EditorGUILayout.PropertyField(useSharedMaterial);
if (target.renderer)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(materialIndex);
if (EditorGUI.EndChangeCheck())
{
materialIndex.intValue = Mathf.Clamp(materialIndex.intValue, 0, target.renderer.sharedMaterials.Length - 1);
}
}
}
serializedObject.ApplyModifiedProperties();
EditorGUILayout.Space();
material = target.material;
if (material)
{
// (重新)建立属性表
if (shader != material.shader)
{
shader = material.shader;
int count = ShaderUtil.GetPropertyCount(shader);
List <int> indexList = new List <int>(count);
for (int i = 0; i < count; i++)
{
if (ShaderUtil.GetPropertyType(shader, i) == target.propertyType)
{
indexList.Add(i);
}
}
propertyIndex = indexList.ToArray();
propertyName = new string[propertyIndex.Length];
propertyDescription = new string[propertyIndex.Length];
for (int i = 0; i < propertyIndex.Length; i++)
{
propertyName[i] = ShaderUtil.GetPropertyName(shader, propertyIndex[i]);
propertyDescription[i] = ShaderUtil.GetPropertyDescription(shader, propertyIndex[i]);
}
if (propertyName.Length > 0)
{
menuIndex = System.Array.IndexOf(propertyName, target.propertyName);
if (menuIndex < 0)
{
Undo.RecordObject(target, undoString);
target.propertyName = propertyName[menuIndex = 0];
EditorUtility.SetDirty(target);
}
}
}
// 绘制属性和子类参数
if (propertyName.Length > 0)
{
DrawIntPopupLayout(menuIndex, propertyDescription, value => target.propertyName = propertyName[menuIndex = value], "Property");
OnDrawSubclass();
return;
}
}
EditorGUILayout.LabelField("* No material or available property.");
}
public static void DRAW_PANEL()
{
bool GUI_TEMP = GUI.enabled;
int CART_temp = KP.MAT_CART_INDEX;
int FAM_temp = KP.MAT_FAM_INDEX;
int TYP_temp = KP.MAT_TYPE_INDEX;
if (ME_LIST == null)
{
ME_LIST = new List <MaterialEditor>(4);
Material m = new Material(Shader.Find("Diffuse"));
MaterialEditor me;
for (int i = 0, n = 5; i < n; i++)
{
me = Editor.CreateEditor(m) as MaterialEditor;
me.SetTexture("_mainTexture", kLibary.LoadBitmap("create", 25, 25));
ME_LIST.Add(me);
}
}
//GUI.enabled = (_selection != null);
// GUILayoutOption glo = { };
EditorGUILayout.BeginVertical(); //----------------------------------------------------------> Begin Vertical
EditorGUI.BeginChangeCheck();
GUILayout.Space(2);
// Material operation and selection slots
KP.FOLD_mSele = EditorGUILayout.Foldout(KP.FOLD_mSele, "Material Operation ");
if (KP.FOLD_mSele)
{
KP.MAT_SELE_INDEX = GUILayout.Toolbar(KP.MAT_SELE_INDEX, new string[] { "Get", "Set", "2file", "2data" });
//KP.MAT_SELE_INDEX = GUILayout.Toolbar(KP.MAT_SELE_INDEX, new string[] { "MAT I", "MAT II", "MAT III" });
EditorGUILayout.BeginHorizontal();
for (int i = 0, n = 4; i < n; i++)
{
GUILayout.BeginVertical();
GUILayout.Box(new GUIContent("Slot " + i), GUILayout.ExpandWidth(true), GUILayout.Height(22));
// Debug.Log(ME_LIST[i]);
MaterialEditor med = ME_LIST[i];
if (med && Event.current.type == EventType.layout)
{
med.OnPreviewGUI(GUILayoutUtility.GetRect(45, 45), EditorStyles.whiteLabel);
}
GUILayout.EndVertical();
GUILayout.Space(2);
}
EditorGUILayout.EndHorizontal();
}
KP.FOLD_object = EditorGUILayout.Foldout(KP.FOLD_object, "Shader Family ");
if (KP.FOLD_object)
{
// Material category
KP.MAT_CART_INDEX = EditorGUILayout.Popup(KP.MAT_CART_INDEX, kShaderLab.CATEGORY);
GUILayout.Space(2);
// Material family
KP.MAT_FAM_INDEX = GUILayout.SelectionGrid(KP.MAT_FAM_INDEX, kShaderLab.FAMILY, 2, KP_Style.grid(), GUILayout.MinWidth(100));
}
// Material type
KP.FOLD_type = EditorGUILayout.Foldout(KP.FOLD_type, "Shader Type ");
if (KP.FOLD_type)
{
//sc1 = EditorGUILayout.BeginScrollView(sc1, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true), GUILayout.MaxHeight(250), GUILayout.MinHeight(20));
KP.MAT_TYPE_INDEX = GUILayout.SelectionGrid(KP.MAT_TYPE_INDEX, kShaderLab.GetShaderList(KP.MAT_FAM_INDEX), 1, KP_Style.grid());
//EditorGUILayout.EndScrollView();
}
// Material NAME
KP.FOLD_name = EditorGUILayout.Foldout(KP.FOLD_name, "Material Name");
if (KP.FOLD_name)
{
KP._meshName = EditorGUILayout.TextField(KP._meshName, KP_Style.tf_input_center());
}
// Material shader properties
KP.FOLD_para = EditorGUILayout.Foldout(KP.FOLD_para, "Material Parameters");
if (KP.FOLD_para)
{
Shader s = (KP._sMaterial != null) ? kShaderLab.GetShader(KP.MAT_CART_INDEX, KP.MAT_FAM_INDEX, KP.MAT_TYPE_INDEX) : null;
if (s != null)
{
//Debug.Log(s.name);
//EditorGUILayout.LabelField("sName : " + s.name);
int n = ShaderUtil.GetPropertyCount(s);
for (int i = 0; i < n; i++)
{
// foreach property in current selected
string label = ShaderUtil.GetPropertyDescription(s, i);
string propertyName = ShaderUtil.GetPropertyName(s, i);
//Debug.Log(ShaderUtil.GetPropertyType(s, i));
switch (ShaderUtil.GetPropertyType(s, i))
{
case ShaderUtil.ShaderPropertyType.Range: // float ranges
{
//GUILayout.BeginHorizontal();
float v2 = ShaderUtil.GetRangeLimits(s, i, 1);
float v3 = ShaderUtil.GetRangeLimits(s, i, 2);
RangeProperty(propertyName, label, v2, v3);
//GUILayout.EndHorizontal();
break;
}
case ShaderUtil.ShaderPropertyType.Float: // floats
Debug.Log(label);
FloatProperty(propertyName, label);
break;
case ShaderUtil.ShaderPropertyType.Color: // colors
{
ColorProperty(propertyName, label);
break;
}
case ShaderUtil.ShaderPropertyType.TexEnv: // textures
{
ShaderUtil.ShaderPropertyTexDim desiredTexdim = ShaderUtil.GetTexDim(s, i);
TextureProperty(propertyName, label, desiredTexdim);
//GUILayout.Space(6);
break;
}
case ShaderUtil.ShaderPropertyType.Vector: // vectors
{
Debug.Log(label);
//VectorProperty(propertyName, label);
break;
}
default:
{
GUILayout.Label("ARGH" + label + " : " + ShaderUtil.GetPropertyType(s, i));
break;
}
}
}
}
}
if (EditorGUI.EndChangeCheck())
{
Debug.Log("REPAINT GUI");
if (CART_temp != KP.MAT_CART_INDEX ||
FAM_temp != KP.MAT_FAM_INDEX ||
TYP_temp != KP.MAT_TYPE_INDEX)
{
if (KP.MAT_SELE_INDEX != -1)
{
KP.Reset_material();
}
}
if (KP.MAT_SELE_INDEX != -1)
{
switch (KP.MAT_SELE_INDEX)
{
case 0: KP._sMaterial = kSelect.MATERIAL; break;
case 1: kSelect.MATERIAL = KP._sMaterial; break;
case 2: break;
case 3: break;
}
KP.MAT_SELE_INDEX = -1;
}
kPoly2Tool.instance.Repaint();
}
EditorGUILayout.EndVertical(); //------------------------------------------------------------> End Vertical
//GUILayout.Space(10);
//GUILayout.EndHorizontal();
GUI.enabled = GUI_TEMP;
}
public override void OnInspectorGUI()
{
//base.OnInspectorGUI ();
ChangeMaterialProperty t = target as ChangeMaterialProperty;
EditorGUI.BeginChangeCheck();
Undo.RecordObject(t, "Change value");
Shader s = t.GetComponent <Renderer>().sharedMaterial.shader;
List <string> descriptions = new List <string>();
List <int> indices = new List <int>();
for (int i = 0; i < ShaderUtil.GetPropertyCount(s); i++)
{
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(s, i);
if (type == ShaderUtil.ShaderPropertyType.Color || type == ShaderUtil.ShaderPropertyType.Float || type == ShaderUtil.ShaderPropertyType.Range)
{
descriptions.Add(ShaderUtil.GetPropertyDescription(s, i));
indices.Add(i);
}
}
int descriptionsIndex = EditorGUILayout.Popup("Property", indices.IndexOf(t.propertyIndex), descriptions.ToArray());
if (descriptionsIndex > 0)
{
t.propertyIndex = indices[descriptionsIndex];
t.stored_propertyName = ShaderUtil.GetPropertyName(s, t.propertyIndex);
switch (ShaderUtil.GetPropertyType(s, t.propertyIndex))
{
case ShaderUtil.ShaderPropertyType.Float:
case ShaderUtil.ShaderPropertyType.Range:
t.stored_propertyType = typeof(float).ToString();
break;
case ShaderUtil.ShaderPropertyType.Color:
t.stored_propertyType = typeof(Color).ToString();
break;
}
}
else
{
t.propertyIndex = 0;
}
if (t.propertyIndex >= 0)
{
ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(s, t.propertyIndex);
if (type == ShaderUtil.ShaderPropertyType.Float)
{
t.value_float = EditorGUILayout.FloatField("Value", t.value_float);
}
else if (type == ShaderUtil.ShaderPropertyType.Range)
{
t.value_float = EditorGUILayout.Slider("Value", t.value_float, ShaderUtil.GetRangeLimits(s, t.propertyIndex, 1), ShaderUtil.GetRangeLimits(s, t.propertyIndex, 2));
}
else if (type == ShaderUtil.ShaderPropertyType.Color)
{
t.value_color = EditorGUILayout.ColorField("Color", t.value_color);
}
}
if (EditorGUI.EndChangeCheck())
{
EditorUtility.SetDirty(t);
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
lastWidth = position.width;
var initialPosition = position;
var labelWidth = EditorGUIUtility.labelWidth;
position.y += EditorGUIUtility.singleLineHeight * 0.2f;
position.height = EditorGUIUtility.singleLineHeight;
var rendererPosition = position;
rendererPosition.width = position.width / 2;
Shift(ref rendererPosition, false);
var renderer = property.FindPropertyRelative("Renderer");
EditorGUI.PropertyField(rendererPosition, renderer, GUIContent.none);
var menu = new GenericMenu();
var useCutoutProperty = property.FindPropertyRelative("CutoutDescriptionType");
var cutoutIsInUse = useCutoutProperty.intValue != (int)CutoutDescriptionType.None;
menu.AddItem(new GUIContent("none"), !cutoutIsInUse, () =>
{
useCutoutProperty.intValue = (int)CutoutDescriptionType.None;
useCutoutProperty.serializedObject.ApplyModifiedProperties();
});
var textureNameProperty = property.FindPropertyRelative("cutoutTextureName");
var rendererReference = renderer.objectReferenceValue as Renderer;
var referenceName = "none";
var usingCutout = cutoutIsInUse && rendererReference != null;
if (rendererReference != null)
{
var material = rendererReference.sharedMaterial;
if (material != null)
{
var propertiesCount = ShaderUtil.GetPropertyCount(material.shader);
for (var index = 0; index < propertiesCount; index++)
{
var propertyType = ShaderUtil.GetPropertyType(material.shader, index);
if (propertyType != ShaderUtil.ShaderPropertyType.TexEnv)
{
continue;
}
var propertyName = ShaderUtil.GetPropertyName(material.shader, index);
var equals = propertyName == textureNameProperty.stringValue;
if (equals)
{
referenceName = ShaderUtil.GetPropertyDescription(material.shader, index);
}
menu.AddItem(new GUIContent(ShaderUtil.GetPropertyDescription(material.shader, index)), equals && usingCutout, () =>
{
textureNameProperty.stringValue = propertyName;
useCutoutProperty.intValue = (int)CutoutDescriptionType.Hash;
textureNameProperty.serializedObject.ApplyModifiedProperties();
});
}
}
}
var cutoutPosition = position;
cutoutPosition.x = rendererPosition.x + rendererPosition.width;
cutoutPosition.width -= rendererPosition.width;
Shift(ref cutoutPosition, true);
var sourceLable = usingCutout ? referenceName : "none";
if (EditorGUI.DropdownButton(cutoutPosition, new GUIContent("Cutout source: " + sourceLable), FocusType.Passive))
{
menu.ShowAsContext();
}
var drawingPosition = position;
EditorGUIUtility.labelWidth = 160;
drawingPosition.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
var forceRecalculateBoundsDrawingPosition = initialPosition;
forceRecalculateBoundsDrawingPosition.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing * 3.0f;
forceRecalculateBoundsDrawingPosition.width = initialPosition.width;
forceRecalculateBoundsDrawingPosition.height = EditorGUIUtility.singleLineHeight;
EditorGUI.PropertyField(forceRecalculateBoundsDrawingPosition, property.FindPropertyRelative("ForceRecalculateBounds"));
forceRecalculateBoundsDrawingPosition.width /= 2;
forceRecalculateBoundsDrawingPosition.x += forceRecalculateBoundsDrawingPosition.width;
EditorGUIUtility.labelWidth = 80;
Shift(ref forceRecalculateBoundsDrawingPosition, true);
EditorGUI.PropertyField(forceRecalculateBoundsDrawingPosition, property.FindPropertyRelative("cutoutTextureIndex"), new GUIContent("Texture index"));
EditorGUIUtility.labelWidth = labelWidth;
if (usingCutout || rendererReference is SpriteRenderer)
{
drawingPosition.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
EditorGUI.PropertyField(drawingPosition, property.FindPropertyRelative("CutoutThreshold"));
}
else
{
var isDilateRenderingMode = property.FindPropertyRelative("DilateRenderingMode").intValue == (int)DilateRenderMode.EdgeShift;
var appropriateToUseEdgeDilate = renderer.objectReferenceValue != null && !(renderer.objectReferenceValue as Renderer).gameObject.isStatic;
if (appropriateToUseEdgeDilate)
{
drawingPosition.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
}
var modeDrawingPosition = drawingPosition;
modeDrawingPosition.width /= 2;
if (appropriateToUseEdgeDilate)
{
Shift(ref modeDrawingPosition, false);
EditorGUI.LabelField(modeDrawingPosition, property.FindPropertyRelative("DilateRenderingMode").displayName);
modeDrawingPosition.x += modeDrawingPosition.width;
Shift(ref modeDrawingPosition, true);
var initialColor = GUI.color;
if (isDilateRenderingMode && PlayerSettings.stripUnusedMeshComponents)
{
GUI.color = Color.red;
}
EditorGUI.PropertyField(modeDrawingPosition, property.FindPropertyRelative("DilateRenderingMode"), GUIContent.none);
GUI.color = initialColor;
}
if (isDilateRenderingMode && appropriateToUseEdgeDilate)
{
drawingPosition.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
if (PlayerSettings.stripUnusedMeshComponents)
{
var helpBoxPosition = drawingPosition;
var buttonStart = EditorStyles.helpBox.CalcHeight(errorContent, lastWidth - 60) + EditorGUIUtility.standardVerticalSpacing;
helpBoxPosition.height = buttonStart + EditorGUIUtility.singleLineHeight * 2.0f;
EditorGUI.HelpBox(helpBoxPosition, errorContent.text, MessageType.Error);
var buttonPosition = drawingPosition;
buttonPosition.y = helpBoxPosition.y + buttonStart + EditorGUIUtility.singleLineHeight * 0.5f;
buttonPosition.width -= EditorGUIUtility.singleLineHeight * 2.0f;
buttonPosition.x += EditorGUIUtility.singleLineHeight;
if (GUI.Button(buttonPosition, "Disable 'Optimize mesh data' option"))
{
PlayerSettings.stripUnusedMeshComponents = false;
}
drawingPosition.y += helpBoxPosition.height + EditorGUIUtility.singleLineHeight;
}
var shiftDrawingPosition = drawingPosition;
shiftDrawingPosition.width /= 2;
var parentRenderStyle = property.serializedObject.FindProperty("renderStyle");
if (parentRenderStyle.intValue == (int)RenderStyle.Single)
{
EditorGUI.LabelField(shiftDrawingPosition, "Edge shift");
shiftDrawingPosition.x += shiftDrawingPosition.width;
Shift(ref shiftDrawingPosition, true);
EditorGUI.PropertyField(shiftDrawingPosition, property.FindPropertyRelative("edgeDilateAmount"), GUIContent.none);
}
else
{
EditorGUIUtility.labelWidth = 80;
Shift(ref shiftDrawingPosition, false);
EditorGUI.PropertyField(shiftDrawingPosition, property.FindPropertyRelative("frontEdgeDilateAmount"), new GUIContent("Front dilate"));
shiftDrawingPosition.x += shiftDrawingPosition.width;
Shift(ref shiftDrawingPosition, true);
EditorGUI.PropertyField(shiftDrawingPosition, property.FindPropertyRelative("backEdgeDilateAmount"), new GUIContent("Back dilate"));
EditorGUIUtility.labelWidth = labelWidth;
}
}
}
drawingPosition.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
var linePosition = drawingPosition;
linePosition.width /= 2;
Shift(ref linePosition, false);
var cullPosition = linePosition;
cullPosition.width /= 2;
EditorGUI.LabelField(cullPosition, new GUIContent("Cull mode"));
cullPosition.x += cullPosition.width;
EditorGUI.PropertyField(cullPosition, property.FindPropertyRelative("CullMode"), GUIContent.none);
linePosition.x += linePosition.width;
Shift(ref linePosition, true);
var submeshIndex = property.FindPropertyRelative("SubmeshIndex");
EditorGUIUtility.labelWidth = 90;
EditorGUI.PropertyField(linePosition, submeshIndex);
if (submeshIndex.intValue < 0)
{
submeshIndex.intValue = 0;
}
EditorGUIUtility.labelWidth = labelWidth;
property.serializedObject.ApplyModifiedProperties();
}
private void ShaderPropertyImpl(Material owner, Shader shader, int propertyIndex)
{
int i = propertyIndex;
string label = ShaderUtil.GetPropertyDescription(shader, i);
string propertyName = ShaderUtil.GetPropertyName(shader, i);
switch (ShaderUtil.GetPropertyType(shader, i))
{
case ShaderUtil.ShaderPropertyType.Range: // float ranges
{
GUILayout.BeginHorizontal();
float v2 = ShaderUtil.GetRangeLimits(shader, i, 1);
float v3 = ShaderUtil.GetRangeLimits(shader, i, 2);
RangeProperty(propertyName, label, v2, v3);
GUILayout.EndHorizontal();
break;
}
case ShaderUtil.ShaderPropertyType.Float: // floats
{
FloatProperty(propertyName, label);
break;
}
case ShaderUtil.ShaderPropertyType.Color: // colors
{
ColorProperty(propertyName, label);
break;
}
case ShaderUtil.ShaderPropertyType.TexEnv: // textures
{
var fxTextureType = FXMaterialHelper.GetFXTextureType(ShaderUtil.GetPropertyDescription(shader, i));
if (fxTextureType != null)
{
if (!(Selection.activeObject is GameObject))
{
if (DisplayHelpTexts)
{
GUILayout.Label(label);
EditorGUILayout.HelpBox(label + " is a FXTexture, you can use a FXTextureAssigner or a FXPostProcess component to set this Texture.", MessageType.Info);
}
else
{
break;
}
}
else
{
var match = Regex.Match(label, @"(.*)\(\w*\).*", RegexOptions.IgnoreCase);
var description = match.Groups[1].Value.Trim();
var name = ShaderUtil.GetPropertyName(shader, i);
FXRenderTexture oldFxRenderTexture = GetRenderTextureForProperty(owner, shader, name);
var newFxRenderTexture = (FXRenderTexture)EditorGUILayout.ObjectField(description + " (FXRenderTexture)", oldFxRenderTexture, typeof(FXRenderTexture), false);
SetRenderTextureForProperty(owner, shader, name, description, newFxRenderTexture);
}
}
else
{
ShaderUtil.ShaderPropertyTexDim desiredTexdim = ShaderUtil.GetTexDim(shader, i);
TextureProperty(propertyName, label, desiredTexdim);
}
GUILayout.Space(6);
break;
}
case ShaderUtil.ShaderPropertyType.Vector: // vectors
{
VectorProperty(propertyName, label);
break;
}
default:
{
GUILayout.Label("Unknown " + label + " : " + ShaderUtil.GetPropertyType(shader, i));
break;
}
}
}
private static void _Create(Shader shader, string bundleName, string variantName)
{
if (shader == null)
{
throw new System.ArgumentNullException("shader");
}
int propertyCount = ShaderUtil.GetPropertyCount(shader);
RuntimeShaderInfo shaderInfo = new RuntimeShaderInfo();
shaderInfo.Name = shader.name;
if (!shader.HasMappedInstanceID())
{
//bool create = EditorUtility.DisplayDialog("RuntimeShaderInfo Generator", "Unable to create RuntimeShaderInfo. Please Create or Update ResourceMap", "Create", "Cancel");
//if (create)
//{
// ResourceMapGen.CreateResourceMap(true);
//}
return;
}
shaderInfo.InstanceId = shader.GetMappedInstanceID();
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);
}
string fullPath = Application.dataPath + RuntimeShaderUtil.GetPath(true);
Directory.CreateDirectory(fullPath);
string fileName = RuntimeShaderUtil.GetShaderInfoFileName(shader);
string path = Path.Combine(fullPath, fileName);
bool refresh = !File.Exists(path);
File.WriteAllText(path, JsonUtility.ToJson(shaderInfo));
if (refresh)
{
AssetDatabase.Refresh();
}
}
