public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawHeader(property);
var attr = PropertyUtility.GetAttribute <PowerSlideAttribute>(property);
if (attr.BaseRcpLn == 0 | attr.BaseRcpLn == float.NaN)
{
EditorDrawUtility.DrawHelpBox($"Invalid Base: {attr.Base}", MessageType.Warning, context: PropertyUtility.GetTargetObject(property));
EditorDrawUtility.DrawPropertyField(property);
return;
}
if (property.propertyType == SerializedPropertyType.Integer)
{
float value = math.log(property.intValue) * attr.BaseRcpLn;
EditorGUI.BeginChangeCheck();
EditorGUILayout.PrefixLabel($"{property.displayName}[{property.intValue}]");
value = EditorGUILayout.Slider(value, attr.MinPower, attr.MaxPower);
property.intValue = (int)math.round(math.pow(attr.Base, value));
}
else if (property.propertyType == SerializedPropertyType.Float)
{
float value = math.log(property.floatValue) * attr.BaseRcpLn;
EditorGUI.BeginChangeCheck();
EditorGUILayout.PrefixLabel($"{property.displayName}[{property.floatValue}]");
value = EditorGUILayout.Slider(value, attr.MinPower, attr.MaxPower);
property.floatValue = math.pow(attr.Base, value);
}
else
{
string warning = attr.GetType().Name + " can be used only on int or float fields";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, context: PropertyUtility.GetTargetObject(property));
EditorDrawUtility.DrawPropertyField(property);
}
}
public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawHeader(property);
if (property.propertyType == SerializedPropertyType.String)
{
EditorGUILayout.LabelField(property.displayName);
EditorGUI.BeginChangeCheck();
string textAreaValue = EditorGUILayout.TextArea(property.stringValue, GUILayout.MinHeight(EditorGUIUtility.singleLineHeight * 3f));
if (EditorGUI.EndChangeCheck())
{
property.stringValue = textAreaValue;
}
}
else
{
string warning = PropertyUtility.GetAttribute <ResizableTextAreaAttribute>(property).GetType().Name + " can only be used on string fields";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: PropertyUtility.GetTargetObject(property));
EditorDrawUtility.DrawPropertyField(property);
}
}
public override void ValidateProperty(SerializedProperty property, bool drawField)
{
RequiredAttribute requiredAttribute = PropertyUtility.GetAttribute <RequiredAttribute>(property);
if (requiredAttribute.HideWithField && !drawField)
{
return;
}
if (property.propertyType == SerializedPropertyType.ObjectReference)
{
if (property.objectReferenceValue == null)
{
string errorMessage = property.name + " is required";
if (!string.IsNullOrEmpty(requiredAttribute.Message))
{
errorMessage = requiredAttribute.Message;
}
EditorDrawUtility.DrawHelpBox(errorMessage, MessageType.Error, logToConsole: true, context: PropertyUtility.GetTargetObject(property));
}
}
else
{
string warning = requiredAttribute.GetType().Name + " works only on reference types";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: PropertyUtility.GetTargetObject(property));
}
}
protected void DrawField(FieldInfo field)
{
EditorGUI.BeginChangeCheck();
PropertyDrawer drawer = this.GetPropertyDrawerForField(field);
if (drawer != null)
{
drawer.FieldInfo = field;
drawer.DrawProperty(this.serializedPropertiesByFieldName[field.Name]);
drawer.FieldInfo = null;
drawer = null;
}
else
{
EditorDrawUtility.DrawPropertyField(this.serializedPropertiesByFieldName[field.Name]);
}
if (EditorGUI.EndChangeCheck())
{
OnValueChangedAttribute[] onValueChangedAttributes = (OnValueChangedAttribute[])field.GetCustomAttributes(typeof(OnValueChangedAttribute), true);
foreach (var onValueChangedAttribute in onValueChangedAttributes)
{
PropertyMeta meta = PropertyMetaDatabase.GetMetaForAttribute(onValueChangedAttribute.GetType());
if (meta != null)
{
meta.ApplyPropertyMeta(this.serializedPropertiesByFieldName[field.Name], onValueChangedAttribute);
}
}
}
}
public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawPropertyField(property);
if (property.propertyType == SerializedPropertyType.ObjectReference)
{
if (property.objectReferenceValue != null)
{
Texture2D previewTexture = AssetPreview.GetAssetPreview(property.objectReferenceValue);
if (previewTexture != null)
{
ShowAssetPreviewAttribute showAssetPreviewAttribute = PropertyUtility.GetAttribute <ShowAssetPreviewAttribute>(property);
int width = Mathf.Clamp(showAssetPreviewAttribute.Width, 0, previewTexture.width);
int height = Mathf.Clamp(showAssetPreviewAttribute.Height, 0, previewTexture.height);
GUILayout.Label(previewTexture, GUILayout.MaxWidth(width), GUILayout.MaxHeight(height));
}
else
{
string warning = property.name + " doesn't have an asset preview";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: PropertyUtility.GetTargetObject(property));
}
}
}
else
{
string warning = property.name + " doesn't have an asset preview";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: PropertyUtility.GetTargetObject(property));
}
}
public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawHeader(property);
if (property.isArray)
{
var listView = GetListView(property);
listView.DoLayoutList();
if (listView.HasKeyboardControl())
{
if (Event.current.type == EventType.KeyDown)
{
if (Event.current.keyCode == KeyCode.Delete || Event.current.keyCode == KeyCode.KeypadMinus)
{
if (listView.onCanRemoveCallback(listView))
{
listView.onRemoveCallback(listView);
}
}
else if (Event.current.keyCode == KeyCode.KeypadPlus)
{
listView.onAddCallback(listView);
}
}
}
}
else
{
string warning = typeof(ReorderableListAttribute).Name + " can be used only on arrays or lists";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, context: PropertyUtility.GetTargetObject(property));
EditorDrawUtility.DrawPropertyField(property);
}
}
public override void DrawMethod(UnityEngine.Object target, MethodInfo methodInfo)
{
if (methodInfo.GetParameters().Length == 0)
{
ButtonAttribute buttonAttribute = (ButtonAttribute)methodInfo.GetCustomAttributes(typeof(ButtonAttribute), true)[0];
string buttonText = string.IsNullOrEmpty(buttonAttribute.Text) ? methodInfo.Name : buttonAttribute.Text;
// Check are we selecting im project folder or in hierarchy window.
var IsAssetSelection = Selection.activeTransform == null;
var activeInPlayMode = EditorApplication.isPlaying && !buttonAttribute.activeInPlayMode;
var activeInEditMode = !EditorApplication.isPlaying && !buttonAttribute.activeInEditMode;
var enabled = activeInPlayMode ? false : activeInEditMode ? false : true;
if (enabled)
{
if (!activeInEditMode && IsAssetSelection) // Disable button if we select an asset (like prefab). It does not matter if we are in playMode.
{
enabled = false;
}
}
GUI.enabled = enabled;
if (GUILayout.Button(buttonText))
{
methodInfo.Invoke(target, null);
}
GUI.enabled = true;
}
else
{
string warning = typeof(ButtonAttribute).Name + " works only on methods with no parameters";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, context: target);
}
}
public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawPropertyField(property);
if (property.propertyType == SerializedPropertyType.ObjectReference)
{
if (property.objectReferenceValue != null)
{
Texture2D previewTexture = AssetPreview.GetAssetPreview(property.objectReferenceValue);
if (previewTexture != null)
{
ShowAssetPreviewAttribute showAssetPreviewAttribute = PropertyUtility.GetAttribute <ShowAssetPreviewAttribute>(property);
int width = Mathf.Clamp(showAssetPreviewAttribute.Width, 0, previewTexture.width);
int height = Mathf.Clamp(showAssetPreviewAttribute.Height, 0, previewTexture.height);
GUILayout.Label(previewTexture, GUILayout.MaxWidth(width), GUILayout.MaxHeight(height));
}
else
{
this.DrawWarningBox(property.name + " doesn't have an asset preview", property);
}
}
}
else
{
this.DrawWarningBox(property.name + " doesn't have an asset preview", property);
}
}
public override bool CanDrawProperty(SerializedProperty property)
{
HideIfAttribute hideIfAttribute = PropertyUtility.GetAttribute <HideIfAttribute>(property);
UnityEngine.Object target = PropertyUtility.GetTargetObject(property);
FieldInfo conditionField = ReflectionUtility.GetField(target, hideIfAttribute.ConditionName);
if (conditionField != null &&
conditionField.FieldType == typeof(bool))
{
return(!(bool)conditionField.GetValue(target));
}
MethodInfo conditionMethod = ReflectionUtility.GetMethod(target, hideIfAttribute.ConditionName);
if (conditionMethod != null &&
conditionMethod.ReturnType == typeof(bool) &&
conditionMethod.GetParameters().Length == 0)
{
return(!(bool)conditionMethod.Invoke(target, null));
}
string warning = hideIfAttribute.GetType().Name + " needs a valid boolean condition field or method name to work";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: target);
return(true);
}
public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawHeader(property);
if (property.propertyType != SerializedPropertyType.Float && property.propertyType != SerializedPropertyType.Integer)
{
EditorGUILayout.HelpBox("Field " + property.name + " is not a number", MessageType.Warning);
return;
}
var value = property.propertyType == SerializedPropertyType.Integer ? property.intValue : property.floatValue;
var valueFormatted = property.propertyType == SerializedPropertyType.Integer ? value.ToString() : String.Format("{0:0.00}", value);
ProgressBarAttribute progressBarAttribute = PropertyUtility.GetAttribute <ProgressBarAttribute>(property);
var position = EditorGUILayout.GetControlRect();
var maxValue = progressBarAttribute.MaxValue;
float lineHight = EditorGUIUtility.singleLineHeight;
float padding = EditorGUIUtility.standardVerticalSpacing;
var barPosition = new Rect(position.position.x, position.position.y, position.size.x, lineHight);
var fillPercentage = value / maxValue;
var barLabel = (!string.IsNullOrEmpty(progressBarAttribute.Name) ? "[" + progressBarAttribute.Name + "] " : "") + valueFormatted + "/" + maxValue;
var color = GetColor(progressBarAttribute.Color);
var color2 = Color.white;
DrawBar(barPosition, Mathf.Clamp01(fillPercentage), barLabel, color, color2);
}
public override void DrawProperty(FieldInfo fieldInfo, SerializedProperty property)
{
EditorDrawUtility.DrawHeader(property);
Enum targetEnum = (Enum)fieldInfo.GetValue(property.serializedObject.targetObject);
Enum enumNew = EditorGUILayout.EnumFlagsField(property.displayName, targetEnum);
property.intValue = (int)Convert.ChangeType(enumNew, targetEnum.GetType());
}
public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawHeader(property);
if (property.isArray)
{
if (!this.reorderableListsByPropertyName.ContainsKey(property.name))
{
ReorderableList reorderableList = new ReorderableList(property.serializedObject, property, true, true, true, true)
{
drawHeaderCallback = (Rect rect) =>
{
EditorGUI.LabelField(rect, string.Format("{0}: {1}", property.displayName, property.arraySize), EditorStyles.label);
},
drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) =>
{
var element = property.GetArrayElementAtIndex(index);
rect.y += 2f;
var key = "";
if (element != null && element.objectReferenceValue != null)
{
key = element.objectReferenceValue.GetType().GetField("Key").GetValue(element.objectReferenceValue) as string;
}
using (var scope = new EditorGUILayout.HorizontalScope())
{
EditorGUI.LabelField(new Rect(rect.x, rect.y, 30, EditorGUIUtility.singleLineHeight), "Key");
key = EditorGUI.TextField(new Rect(rect.x + 30, rect.y, rect.width * 0.3f, EditorGUIUtility.singleLineHeight), key);
if (element != null && element.objectReferenceValue != null)
{
element.objectReferenceValue.GetType().GetField("Key").SetValue(element.objectReferenceValue, key);
}
EditorGUIUtility.labelWidth = 53;
EditorGUI.PropertyField(new Rect(rect.x + 30 + rect.width * 0.35f, rect.y, rect.width * 0.65f - 30, EditorGUIUtility.singleLineHeight), element);
}
}
};
this.reorderableListsByPropertyName[property.name] = reorderableList;
}
this.reorderableListsByPropertyName[property.name].DoLayoutList();
}
else
{
string warning = typeof(ReorderableKeyListAttribute).Name + " can be used only on arrays or lists";
EditorGUILayout.HelpBox(warning, MessageType.Warning);
Debug.LogWarning(warning, PropertyUtility.GetTargetObject(property));
EditorDrawUtility.DrawPropertyField(property);
}
}
public override void DrawField(UnityEngine.Object target, FieldInfo field)
{
object value = field.GetValue(target);
if (!EditorDrawUtility.DrawLayoutField(value, ObjectNames.NicifyVariableName(field.Name), field.FieldType))
{
string warning = string.Format("{0} doesn't support {1} types", typeof(ShowNonSerializedFieldFieldDrawer).Name, field.FieldType.Name);
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: target);
}
}
public override bool DrawMethod(UnityEngine.Object target, MethodInfo methodInfo)
{
if (methodInfo.GetParameters().Length == 0)
{
ButtonAttribute buttonAttribute = (ButtonAttribute)methodInfo.GetCustomAttributes(typeof(ButtonAttribute), true)[0];
string buttonText = string.IsNullOrEmpty(buttonAttribute.Text) ? methodInfo.Name : buttonAttribute.Text;
if (GUILayout.Button(buttonText))
{
EditorGUI.BeginChangeCheck();
var gameObjects = Selection.gameObjects;
if (gameObjects.Length <= 1 || buttonAttribute.Target == ButtonAttribute.ButtonInvocationTarget.Default)
{
methodInfo.Invoke(target, null);
}
else if (target is Component)
{
var targetType = target.GetType();
if (buttonAttribute.Target == ButtonAttribute.ButtonInvocationTarget.First)
{
var gameObject = Selection.gameObjects[0];
var targetComponent = gameObject.GetComponent(targetType);
methodInfo.Invoke(targetComponent, null);
}
else if (buttonAttribute.Target == ButtonAttribute.ButtonInvocationTarget.All)
{
foreach (var gameObject in Selection.gameObjects)
{
var targetComponent = gameObject.GetComponent(targetType);
methodInfo.Invoke(targetComponent, null);
}
}
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Method Invocation: " + buttonText);
}
return(true);
}
}
else
{
string warning = typeof(ButtonAttribute).Name + " works only on methods with no parameters";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: target);
}
return(false);
}
public override void DrawMethod(UnityEngine.Object target, MethodInfo methodInfo)
{
if (methodInfo.GetParameters().Length == 0)
{
InspectorDrawerAttribute buttonAttribute = (InspectorDrawerAttribute)methodInfo.GetCustomAttributes(typeof(InspectorDrawerAttribute), true)[0];
methodInfo.Invoke(target, null);
}
else
{
string warning = typeof(InspectorDrawerAttribute).Name + " works only on methods with no parameters";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, context: target);
}
}
public override void ValidateProperty(SerializedProperty property, bool drawField)
{
ValidateInputAttribute validateInputAttribute = PropertyUtility.GetAttribute <ValidateInputAttribute>(property);
if (validateInputAttribute.HideWithField && !drawField)
{
return;
}
UnityEngine.Object target = PropertyUtility.GetTargetObject(property);
MethodInfo validationCallback = ReflectionUtility.GetMethod(target, validateInputAttribute.CallbackName);
if (validationCallback != null &&
validationCallback.ReturnType == typeof(bool) &&
validationCallback.GetParameters().Length == 1)
{
FieldInfo fieldInfo = ReflectionUtility.GetField(target, property.name);
Type fieldType = fieldInfo.FieldType;
Type parameterType = validationCallback.GetParameters()[0].ParameterType;
if (fieldType == parameterType)
{
if (!(bool)validationCallback.Invoke(target, new object[] { fieldInfo.GetValue(target) }))
{
if (string.IsNullOrEmpty(validateInputAttribute.Message))
{
EditorDrawUtility.DrawHelpBox(property.name + " is not valid", MessageType.Error, logToConsole: true, context: target);
}
else
{
EditorDrawUtility.DrawHelpBox(validateInputAttribute.Message, MessageType.Error, logToConsole: true, context: target);
}
}
}
else
{
string warning = "The field type is not the same as the callback's parameter type";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: target);
}
}
else
{
string warning =
validateInputAttribute.GetType().Name +
" needs a callback with boolean return type and a single parameter of the same type as the field";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: target);
}
}
public override void DrawField(UnityEngine.Object target, FieldInfo field)
{
object value = field.GetValue(target);
if (value == null)
{
string warning = string.Format("{0} doesn't support {1} types", typeof(ShowNonSerializedFieldFieldDrawer).Name, "Reference");
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, context: target);
}
else if (!EditorDrawUtility.DrawLayoutField(value, field.Name))
{
string warning = string.Format("{0} doesn't support {1} types", typeof(ShowNonSerializedFieldFieldDrawer).Name, field.FieldType.Name);
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, context: target);
}
}
public override void DrawNativeProperty(UnityEngine.Object target, PropertyInfo property)
{
object value = property.GetValue(target, null);
if (value == null)
{
string warning = string.Format("{0} doesn't support {1} types", typeof(ShowNativePropertyNativePropertyDrawer).Name, "Reference");
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: target);
}
else if (!EditorDrawUtility.DrawLayoutField(value, property.Name))
{
string warning = string.Format("{0} doesn't support {1} types", typeof(ShowNativePropertyNativePropertyDrawer).Name, property.PropertyType.Name);
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: target);
}
}
public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawHeader(property);
var attr = PropertyUtility.GetAttribute <PrefabOnlyAttribute>(property);
var type = this.FieldInfo.FieldType;
if (typeof(GameObject).IsAssignableFrom(type) || typeof(Component).IsAssignableFrom(type))
{
property.objectReferenceValue = EditorGUILayout.ObjectField(property.displayName, property.objectReferenceValue, this.FieldInfo.FieldType, false);
}
else
{
EditorDrawUtility.DrawHelpBox($"Field={this.FieldInfo.Name} Type={this.FieldInfo.FieldType.Name} {nameof(PrefabOnlyAttribute)} can only be used on GameObject or Component fields", MessageType.Warning, context: PropertyUtility.GetTargetObject(property));
EditorDrawUtility.DrawPropertyField(property);
}
}
private void DrawField(FieldInfo field)
{
// Check if the field has draw conditions
PropertyDrawCondition drawCondition = this.GetPropertyDrawConditionForField(field);
if (drawCondition != null)
{
bool canDrawProperty = drawCondition.CanDrawProperty(this.serializedPropertiesByFieldName[field.Name]);
if (!canDrawProperty)
{
return;
}
}
// Check if the field has HideInInspectorAttribute
HideInInspector[] hideInInspectorAttributes = (HideInInspector[])field.GetCustomAttributes(typeof(HideInInspector), true);
if (hideInInspectorAttributes.Length > 0)
{
return;
}
// Draw the field
EditorGUI.BeginChangeCheck();
PropertyDrawer drawer = this.GetPropertyDrawerForField(field);
if (drawer != null)
{
drawer.DrawProperty(field, this.serializedPropertiesByFieldName[field.Name]);
}
else
{
EditorDrawUtility.DrawPropertyField(this.serializedPropertiesByFieldName[field.Name]);
}
if (EditorGUI.EndChangeCheck())
{
OnValueChangedAttribute[] onValueChangedAttributes = (OnValueChangedAttribute[])field.GetCustomAttributes(typeof(OnValueChangedAttribute), true);
foreach (var onValueChangedAttribute in onValueChangedAttributes)
{
PropertyMeta meta = PropertyMetaDatabase.GetMetaForAttribute(onValueChangedAttribute.GetType());
if (meta != null)
{
meta.ApplyPropertyMeta(this.serializedPropertiesByFieldName[field.Name], onValueChangedAttribute);
}
}
}
}
public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawHeader(property);
if (property.isArray)
{
var key = GetPropertyKeyName(property);
if (!this.reorderableListsByPropertyName.ContainsKey(key))
{
ReorderableList reorderableList = new ReorderableList(property.serializedObject, property, true, true, true, true)
{
drawHeaderCallback = (Rect rect) =>
{
EditorGUI.LabelField(rect, string.Format("{0}: {1}", property.displayName, property.arraySize), EditorStyles.label);
},
drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) =>
{
var element = property.GetArrayElementAtIndex(index);
rect.y += 1.0f;
rect.x += 10.0f;
rect.width -= 10.0f;
EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width, 0.0f), element, true);
},
elementHeightCallback = (int index) =>
{
return(EditorGUI.GetPropertyHeight(property.GetArrayElementAtIndex(index)) + 4.0f);
}
};
this.reorderableListsByPropertyName[key] = reorderableList;
}
this.reorderableListsByPropertyName[key].DoLayoutList();
}
else
{
string warning = typeof(ReorderableListAttribute).Name + " can be used only on arrays or lists";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, context: PropertyUtility.GetTargetObject(property));
EditorDrawUtility.DrawPropertyField(property);
}
}
public override void DrawMethod(UnityEngine.Object target, MethodInfo methodInfo)
{
if (methodInfo.GetParameters().Length == 0)
{
ButtonAttribute buttonAttribute = (ButtonAttribute)methodInfo.GetCustomAttributes(typeof(ButtonAttribute), true)[0];
string buttonText = string.IsNullOrEmpty(buttonAttribute.Text) ? methodInfo.Name : buttonAttribute.Text;
if (GUILayout.Button(buttonText))
{
methodInfo.Invoke(target, null);
}
}
else
{
string warning = typeof(ButtonAttribute).Name + " works only on methods with no parameters";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, context: target);
}
}
public override void ApplyPropertyMeta(SerializedProperty property, MetaAttribute metaAttribute)
{
var infoBoxAttribute = (InfoBoxAttribute)metaAttribute;
var target = PropertyUtility.GetTargetObject(property);
if (!string.IsNullOrEmpty(infoBoxAttribute.VisibleIf))
{
var conditionField = ReflectionUtility.GetField(target, infoBoxAttribute.VisibleIf);
if (conditionField != null &&
conditionField.FieldType == typeof(bool))
{
if ((bool)conditionField.GetValue(target))
{
DrawInfoBox(infoBoxAttribute.Text, infoBoxAttribute.Type);
}
return;
}
var conditionMethod = ReflectionUtility.GetMethod(target, infoBoxAttribute.VisibleIf);
if (conditionMethod != null &&
conditionMethod.ReturnType == typeof(bool) &&
conditionMethod.GetParameters().Length == 0)
{
if ((bool)conditionMethod.Invoke(target, null))
{
DrawInfoBox(infoBoxAttribute.Text, infoBoxAttribute.Type);
}
return;
}
var warning = infoBoxAttribute.GetType().Name +
" needs a valid boolean condition field or method name to work";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, PropertyUtility.GetTargetObject(property));
}
else
{
DrawInfoBox(infoBoxAttribute.Text, infoBoxAttribute.Type);
}
}
public override void ValidateProperty(SerializedProperty property)
{
var validateInputAttribute = PropertyUtility.GetAttribute <ValidateInputAttribute>(property);
var target = PropertyUtility.GetTargetObject(property);
var validationCallback = ReflectionUtility.GetMethod(target, validateInputAttribute.CallbackName);
if (validationCallback != null &&
validationCallback.ReturnType == typeof(bool) &&
validationCallback.GetParameters().Length == 1)
{
var fieldInfo = ReflectionUtility.GetField(target, property.name);
var fieldType = fieldInfo.FieldType;
var parameterType = validationCallback.GetParameters()[0].ParameterType;
if (fieldType == parameterType)
{
if (!(bool)validationCallback.Invoke(target, new[] { fieldInfo.GetValue(target) }))
{
if (string.IsNullOrEmpty(validateInputAttribute.Message))
{
EditorDrawUtility.DrawHelpBox(property.name + " is not valid", MessageType.Error, target);
}
else
{
EditorDrawUtility.DrawHelpBox(validateInputAttribute.Message, MessageType.Error, target);
}
}
}
else
{
var warning = "The field type is not the same as the callback's parameter type";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, target);
}
}
else
{
var warning =
validateInputAttribute.GetType().Name +
" needs a callback with boolean return type and a single parameter of the same type as the field";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, target);
}
}
public override void ApplyPropertyMeta(SerializedProperty property, MetaAttribute metaAttribute, bool drawField)
{
InfoBoxAttribute infoBoxAttribute = (InfoBoxAttribute)metaAttribute;
UnityEngine.Object target = PropertyUtility.GetTargetObject(property);
if (!string.IsNullOrEmpty(infoBoxAttribute.VisibleIf))
{
FieldInfo conditionField = ReflectionUtility.GetField(target, infoBoxAttribute.VisibleIf);
if (conditionField != null &&
conditionField.FieldType == typeof(bool))
{
if ((bool)conditionField.GetValue(target))
{
this.DrawInfoBox(infoBoxAttribute.Text, infoBoxAttribute.Type);
}
return;
}
MethodInfo conditionMethod = ReflectionUtility.GetMethod(target, infoBoxAttribute.VisibleIf);
if (conditionMethod != null &&
conditionMethod.ReturnType == typeof(bool) &&
conditionMethod.GetParameters().Length == 0)
{
if ((bool)conditionMethod.Invoke(target, null))
{
this.DrawInfoBox(infoBoxAttribute.Text, infoBoxAttribute.Type);
}
return;
}
string warning = infoBoxAttribute.GetType().Name + " needs a valid boolean condition field or method name to work";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: PropertyUtility.GetTargetObject(property));
}
else if (!infoBoxAttribute.HideWithField ||
(drawField && infoBoxAttribute.HideWithField))
{
this.DrawInfoBox(infoBoxAttribute.Text, infoBoxAttribute.Type);
}
}
public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawHeader(property);
var sliderAttribute = PropertyUtility.GetAttribute <SliderAttribute>(property);
if (property.propertyType == SerializedPropertyType.Integer)
{
EditorGUILayout.IntSlider(property, (int)sliderAttribute.MinValue, (int)sliderAttribute.MaxValue);
}
else if (property.propertyType == SerializedPropertyType.Float)
{
EditorGUILayout.Slider(property, sliderAttribute.MinValue, sliderAttribute.MaxValue);
}
else
{
var warning = sliderAttribute.GetType().Name + " can be used only on int or float fields";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, PropertyUtility.GetTargetObject(property));
EditorDrawUtility.DrawPropertyField(property);
}
}
public override void DrawNativeProperty(UnityEngine.Object target, PropertyInfo property)
{
try
{
object value = property.GetValue(target, null);
if (!EditorDrawUtility.DrawLayoutField(value, ObjectNames.NicifyVariableName(property.Name),
property.PropertyType))
{
string warning = string.Format("{0} doesn't support {1} types",
typeof(ShowNativePropertyNativePropertyDrawer).Name,
property.PropertyType.Name);
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, logToConsole: true, context: target);
}
}
catch (Exception e)
{
EditorDrawUtility.DrawHelpBox("Error: " + e, MessageType.Error, logToConsole: true, context: target);
}
}
public override void DrawProperty(SerializedProperty property)
{
bool drawEnabled = false;
bool validCondition = false;
EnableIfAttribute enableIfAttribute = PropertyUtility.GetAttribute <EnableIfAttribute>(property);
UnityEngine.Object target = PropertyUtility.GetTargetObject(property);
FieldInfo conditionField = ReflectionUtility.GetField(target, enableIfAttribute.ConditionName);
if (conditionField != null &&
conditionField.FieldType == typeof(bool))
{
drawEnabled = (bool)conditionField.GetValue(target);
validCondition = true;
}
MethodInfo conditionMethod = ReflectionUtility.GetMethod(target, enableIfAttribute.ConditionName);
if (conditionMethod != null &&
conditionMethod.ReturnType == typeof(bool) &&
conditionMethod.GetParameters().Length == 0)
{
drawEnabled = (bool)conditionMethod.Invoke(target, null);
validCondition = true;
}
if (validCondition)
{
GUI.enabled = drawEnabled;
EditorDrawUtility.DrawPropertyField(property);
GUI.enabled = true;
}
else
{
string warning = enableIfAttribute.GetType().Name + " needs a valid boolean condition field or method name to work";
EditorGUILayout.HelpBox(warning, MessageType.Warning);
Debug.LogWarning(warning, target);
}
}
public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawHeader(property);
if (property.isArray)
{
var key = GetPropertyKeyName(property);
if (!reorderableListsByPropertyName.ContainsKey(key))
{
var reorderableList =
new ReorderableList(property.serializedObject, property, true, true, true, true)
{
drawHeaderCallback = rect =>
{
EditorGUI.LabelField(
rect, string.Format("{0}: {1}", property.displayName, property.arraySize),
EditorStyles.label);
},
drawElementCallback = (rect, index, isActive, isFocused) =>
{
var element = property.GetArrayElementAtIndex(index);
rect.y += 2f;
EditorGUI.PropertyField(
new Rect(rect.x, rect.y, rect.width, EditorGUIUtility.singleLineHeight), element);
}
};
reorderableListsByPropertyName[key] = reorderableList;
}
reorderableListsByPropertyName[key].DoLayoutList();
}
else
{
var warning = typeof(ReorderableListAttribute).Name + " can be used only on arrays or lists";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning, PropertyUtility.GetTargetObject(property));
EditorDrawUtility.DrawPropertyField(property);
}
}
public override void DrawProperty(SerializedProperty property)
{
EditorDrawUtility.DrawHeader(property);
var attr = PropertyUtility.GetAttribute <SceneReferenceOnlyAttribute>(property);
var type = this.FieldInfo.FieldType;
var target = property.serializedObject.targetObject;
if (target is Component)
{
var targetGo = (target as Component).gameObject;
if (typeof(GameObject).IsAssignableFrom(type))
{
var obj = (GameObject)EditorGUILayout.ObjectField(property.displayName, property.objectReferenceValue, this.FieldInfo.FieldType, true);
if (obj == null || obj.scene == targetGo.scene)
{
property.objectReferenceValue = obj;
}
else
{
Debug.LogWarning($"{obj.name} is not in the same scene[{targetGo.scene.name}] with {targetGo.name}", obj);
}
return;
}
else if (typeof(Component).IsAssignableFrom(type))
{
var obj = (Component)EditorGUILayout.ObjectField(property.displayName, property.objectReferenceValue, this.FieldInfo.FieldType, true);
if (obj == null || obj.gameObject.scene == targetGo.scene)
{
property.objectReferenceValue = obj;
}
else
{
Debug.LogWarning($"{obj.name} is not in the same scene[{targetGo.scene.name}] with {targetGo.name}", obj);
}
return;
}
}
EditorDrawUtility.DrawHelpBox($"Field={this.FieldInfo.Name} Type={this.FieldInfo.FieldType.Name} {nameof(SceneReferenceOnlyAttribute)} can only be used on GameObject or Component fields of UnityEngine.Component", MessageType.Warning, context: PropertyUtility.GetTargetObject(property));
EditorDrawUtility.DrawPropertyField(property);
}
