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 bool CanDrawProperty(SerializedProperty property) { ShowIfAttribute showIfAttribute = PropertyUtility.GetAttribute <ShowIfAttribute>(property); UnityEngine.Object target = PropertyUtility.GetTargetObject(property); FieldInfo conditionField = ReflectionUtility.GetField(target, showIfAttribute.ConditionName); if (conditionField != null && conditionField.FieldType == typeof(bool)) { return((bool)conditionField.GetValue(target)); } MethodInfo conditionMethod = ReflectionUtility.GetMethod(target, showIfAttribute.ConditionName); if (conditionMethod != null && conditionMethod.ReturnType == typeof(bool) && conditionMethod.GetParameters().Length == 0) { return((bool)conditionMethod.Invoke(target, null)); } string warning = showIfAttribute.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.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 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); } }
protected override void OnGUI_Internal(Rect rect, SerializedProperty property, GUIContent label) { if (!IsNumber(property)) { string message = string.Format("Field {0} is not a number", property.name); DrawDefaultPropertyAndHelpBox(rect, property, message, MessageType.Warning); return; } ProgressBarAttribute progressBarAttribute = PropertyUtility.GetAttribute <ProgressBarAttribute>(property); var value = property.propertyType == SerializedPropertyType.Integer ? property.intValue : property.floatValue; var valueFormatted = property.propertyType == SerializedPropertyType.Integer ? value.ToString() : string.Format("{0:0.00}", value); var fillPercentage = value / progressBarAttribute.MaxValue; var barLabel = (!string.IsNullOrEmpty(progressBarAttribute.Name) ? "[" + progressBarAttribute.Name + "] " : "") + valueFormatted + "/" + progressBarAttribute.MaxValue; var barColor = progressBarAttribute.Color.GetColor(); var labelColor = Color.white; var indentLength = NaughtyEditorGUI.GetIndentLength(rect); Rect barRect = new Rect() { x = rect.x + indentLength, y = rect.y, width = rect.width - indentLength, height = EditorGUIUtility.singleLineHeight }; DrawBar(barRect, Mathf.Clamp01(fillPercentage), barLabel, barColor, labelColor); }
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)); } }
protected override void OnGUI_Internal(Rect rect, SerializedProperty property, GUIContent label) { EditorGUI.BeginProperty(rect, label, property); // Check user error if (property.propertyType != SerializedPropertyType.AnimationCurve) { string message = string.Format("Field {0} is not an AnimationCurve", property.name); DrawDefaultPropertyAndHelpBox(rect, property, message, MessageType.Warning); return; } if (_cachedCurveRangeAttribute == null) { _cachedCurveRangeAttribute = PropertyUtility.GetAttribute <CurveRangeAttribute>(property); } var attribute = _cachedCurveRangeAttribute; EditorGUI.CurveField( rect, property, attribute.Color == EColor.Clear ? Color.green : attribute.Color.GetColor(), new Rect(attribute.Min.x, attribute.Min.y, attribute.Max.x - attribute.Min.x, attribute.Max.y - attribute.Min.y), label); EditorGUI.EndProperty(); }
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 ValidateProperty(SerializedProperty property) { MinValueAttribute minValueAttribute = PropertyUtility.GetAttribute <MinValueAttribute>(property); if (property.propertyType == SerializedPropertyType.Integer) { if (property.intValue < minValueAttribute.MinValue) { property.intValue = (int)minValueAttribute.MinValue; } } else if (property.propertyType == SerializedPropertyType.Float) { if (property.floatValue < minValueAttribute.MinValue) { property.floatValue = minValueAttribute.MinValue; } } else { string warning = minValueAttribute.GetType().Name + " can be used only on int or float fields"; EditorGUILayout.HelpBox(warning, MessageType.Warning); Debug.LogWarning(warning, PropertyUtility.GetTargetObject(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)); } }
public override void ValidateProperty(SerializedProperty property) { if (_cachedRequiredAttribute == null) { _cachedRequiredAttribute = PropertyUtility.GetAttribute <RequiredAttribute>(property); } RequiredAttribute requiredAttribute = _cachedRequiredAttribute; if (property.propertyType == SerializedPropertyType.ObjectReference) { if (property.objectReferenceValue == null) { string errorMessage = property.name + " is required"; if (!string.IsNullOrEmpty(requiredAttribute.Message)) { errorMessage = requiredAttribute.Message; } NaughtyEditorGUI.HelpBox_Layout(errorMessage, MessageType.Error, context: property.serializedObject.targetObject); } } else { string warning = requiredAttribute.GetType().Name + " works only on reference types"; NaughtyEditorGUI.HelpBox_Layout(warning, MessageType.Warning, context: property.serializedObject.targetObject); } }
public virtual void Prepare() { _nonSerializedFields = ReflectionUtility.GetAllFields( target, f => f.GetCustomAttributes(typeof(ShowNonSerializedFieldAttribute), true).Length > 0).ToList(); _nativeProperties = ReflectionUtility.GetAllProperties( target, p => p.GetCustomAttributes(typeof(ShowNativePropertyAttribute), true).Length > 0).ToList(); _methods = ReflectionUtility.GetAllMethods( target, m => m.GetCustomAttributes(typeof(ButtonAttribute), true).Length > 0).ToList(); GetSerializedProperties(ref _serializedProperties); _anyNaughtyAttribute = _serializedProperties.Any(p => PropertyUtility.GetAttribute <INaughtyAttribute>(p.serializedProperty) != null); _nonGroupedSerializedProperty = GetNonGroupedProperties(_serializedProperties).ToList(); //.First(...) doesnt work for some reason because the m_Script field isnt loaded yet I assume NaughtyProperty[] mScripts = _serializedProperties.Where(p => p.serializedProperty.name.Equals("m_Script")).ToArray(); m_ScriptProperty = mScripts.Length > 0 ? mScripts[0].serializedProperty : null; _groupedSerialzedProperty = GetGroupedProperties(_serializedProperties).ToList(); _foldoutGroupedSerializedProperty = GetFoldoutProperties(_serializedProperties).ToList(); _useCachedMetaAttributes = false; }
protected virtual void OnEnable() { SerializedData entry; if (!data.ContainsKey(target)) { entry = new SerializedData(); data.Add(target, entry); entry._nonSerializedFields = ReflectionUtility.GetAllFields( target, f => f.GetCustomAttributes(typeof(ShowNonSerializedFieldAttribute), true).Length > 0).ToList(); entry._nativeProperties = ReflectionUtility.GetAllProperties( target, p => p.GetCustomAttributes(typeof(ShowNativePropertyAttribute), true).Length > 0).ToList(); entry._methods = ReflectionUtility.GetAllMethods( target, m => m.GetCustomAttributes(typeof(ButtonAttribute), true).Length > 0).ToList(); GetSerializedProperties(ref _serializedProperties); entry._serializedProperties = _serializedProperties; entry._anyNaughtyAttribute = _serializedProperties.Any(p => PropertyUtility.GetAttribute <INaughtyAttribute>(p) != null); entry._anyNativeProperties = entry._nativeProperties.Any(); entry._anyMethods = entry._methods.Any(); } entry = data[target]; _serializedProperties = entry._serializedProperties; _nonSerializedFields = entry._nonSerializedFields; _nativeProperties = entry._nativeProperties; _anyNativeProperties = entry._anyNativeProperties; _methods = entry._methods; _anyMethods = entry._anyMethods; _anyNaughtyAttribute = entry._anyNaughtyAttribute; }
public override void DrawProperty(SerializedProperty property) { var labelAttribute = PropertyUtility.GetAttribute <LabelAttribute>(property); var guiContent = new GUIContent(labelAttribute.Label); EditorGUILayout.PropertyField(property, guiContent, true); }
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"; EditorGUILayout.HelpBox(warning, MessageType.Warning); Debug.LogWarning(warning, target); return(true); }
public override void ValidateProperty(SerializedProperty property) { RequiredAttribute requiredAttribute = PropertyUtility.GetAttribute <RequiredAttribute>(property); if (property.propertyType == SerializedPropertyType.ObjectReference) { if (property.objectReferenceValue == null) { string errorMessage = property.name + " is required"; if (!string.IsNullOrEmpty(requiredAttribute.Message)) { errorMessage = requiredAttribute.Message; } EditorGUILayout.HelpBox(errorMessage, MessageType.Error); Debug.LogError(errorMessage, PropertyUtility.GetTargetObject(property)); } } else { string warning = requiredAttribute.GetType().Name + " works only on reference types"; EditorGUILayout.HelpBox(warning, MessageType.Warning); Debug.LogWarning(warning, PropertyUtility.GetTargetObject(property)); } }
private Vector2 GetAssetPreviewSize(SerializedProperty property) { Texture2D previewTexture = GetAssetPreview(property); if (previewTexture == null) { return(Vector2.zero); } else { int targetWidth = ShowAssetPreviewAttribute.DefaultWidth; int targetHeight = ShowAssetPreviewAttribute.DefaultHeight; if (_cachedShowAssetPreviewAttribute == null) { _cachedShowAssetPreviewAttribute = PropertyUtility.GetAttribute <ShowAssetPreviewAttribute>(property); } ShowAssetPreviewAttribute showAssetPreviewAttribute = _cachedShowAssetPreviewAttribute; if (showAssetPreviewAttribute != null) { targetWidth = showAssetPreviewAttribute.Width; targetHeight = showAssetPreviewAttribute.Height; } int width = Mathf.Clamp(targetWidth, 0, previewTexture.width); int height = Mathf.Clamp(targetHeight, 0, previewTexture.height); return(new Vector2(width, height)); } }
private Texture2D GetAssetPreview(SerializedProperty property) { HeaderImageAttribute headerImageAttribute = PropertyUtility.GetAttribute <HeaderImageAttribute>(property); Texture2D previewTexture = AssetDatabase.LoadAssetAtPath <Texture2D>(headerImageAttribute.Path); return(previewTexture); }
protected override float GetPropertyHeight_Internal(SerializedProperty property, GUIContent label) { ProgressBarAttribute progressBarAttribute = PropertyUtility.GetAttribute <ProgressBarAttribute>(property); var maxValue = GetMaxValue(property, progressBarAttribute); return(IsNumber(property) && IsNumber(maxValue) ? GetPropertyHeight(property) : GetPropertyHeight(property) + GetHelpBoxHeight()); }
protected override float GetPropertyHeight_Internal(SerializedProperty property, GUIContent label) { AnimatorParamAttribute animatorParamAttribute = PropertyUtility.GetAttribute <AnimatorParamAttribute>(property); bool validAnimatorController = GetAnimatorController(property, animatorParamAttribute.AnimatorName) != null; bool validPropertyType = property.propertyType == SerializedPropertyType.Integer || property.propertyType == SerializedPropertyType.String; return((validAnimatorController && validPropertyType) ? GetPropertyHeight(property) : GetPropertyHeight(property) + GetHelpBoxHeight()); }
protected float GetPropertyHeight(SerializedProperty property) { SpecialCaseDrawerAttribute specialCaseAttribute = PropertyUtility.GetAttribute <SpecialCaseDrawerAttribute>(property); if (specialCaseAttribute != null) { return(specialCaseAttribute.GetDrawer().GetPropertyHeight(property)); } return(EditorGUI.GetPropertyHeight(property, includeChildren: true)); }
private static void PropertyField_Implementation(Rect rect, SerializedProperty property, bool includeChildren, PropertyFieldFunction propertyFieldFunction) { SpecialCaseDrawerAttribute specialCaseAttribute = PropertyUtility.GetAttribute <SpecialCaseDrawerAttribute>(property); if (specialCaseAttribute != null) { specialCaseAttribute.GetDrawer().OnGUI(rect, property); } else { GUIContent label = new GUIContent(PropertyUtility.GetLabel(property)); bool anyDrawerAttribute = PropertyUtility.GetAttributes <DrawerAttribute>(property).Any(); if (!anyDrawerAttribute) { // Drawer attributes check for visibility, enableability and validator themselves, // so if a property doesn't have a DrawerAttribute we need to check for these explicitly // Check if visible bool visible = PropertyUtility.IsVisible(property); if (!visible) { return; } // Validate ValidatorAttribute[] validatorAttributes = PropertyUtility.GetAttributes <ValidatorAttribute>(property); foreach (var validatorAttribute in validatorAttributes) { validatorAttribute.GetValidator().ValidateProperty(property); } // Check if enabled and draw EditorGUI.BeginChangeCheck(); bool enabled = PropertyUtility.IsEnabled(property); using (new EditorGUI.DisabledScope(disabled: !enabled)) { propertyFieldFunction.Invoke(rect, property, label, includeChildren); } // Call OnValueChanged callbacks if (EditorGUI.EndChangeCheck()) { PropertyUtility.CallOnValueChangedCallbacks(property); } } else { // We don't need to check for enableIfAttribute propertyFieldFunction.Invoke(rect, property, label, includeChildren); } } }
public static bool DrawHeader(SerializedProperty property) { HeaderAttribute headerAttr = PropertyUtility.GetAttribute <HeaderAttribute>(property); if (headerAttr != null) { DrawHeader(headerAttr.header); return(true); } return(false); }
private static IEnumerable <IGrouping <string, SerializedProperty> > GetGroupedProperties(IEnumerable <SerializedProperty> properties) { return(properties .Where(p => { return PropertyUtility.GetAttribute <BoxGroupAttribute>(p) != null; }) .GroupBy(p => { return PropertyUtility.GetAttribute <BoxGroupAttribute>(p).Name; })); }
public static void PropertyField_Layout(SerializedProperty property, bool includeChildren) { SpecialCaseDrawerAttribute specialCaseAttribute = PropertyUtility.GetAttribute <SpecialCaseDrawerAttribute>(property); if (specialCaseAttribute != null) { specialCaseAttribute.GetDrawer().OnGUI(property); } else { GUIContent label = new GUIContent(PropertyUtility.GetLabel(property)); bool anyDrawerAttribute = PropertyUtility.GetAttributes <DrawerAttribute>(property).Any(); if (!anyDrawerAttribute) { // Drawer attributes check for visibility, enableability and validator themselves, // so if a property doesn't have a DrawerAttribute we need to check for these explicitly // Check if visible bool visible = PropertyUtility.IsVisible(property); if (!visible) { return; } // Validate ValidatorAttribute[] validatorAttributes = PropertyUtility.GetAttributes <ValidatorAttribute>(property); foreach (var validatorAttribute in validatorAttributes) { validatorAttribute.GetValidator().ValidateProperty(property); } // Check if enabled and draw EditorGUI.BeginChangeCheck(); bool enabled = PropertyUtility.IsEnabled(property); GUI.enabled = enabled; EditorGUILayout.PropertyField(property, label, includeChildren); GUI.enabled = true; // Call OnValueChanged callbacks if (EditorGUI.EndChangeCheck()) { PropertyUtility.CallOnValueChangedCallbacks(property); } } else { // We don't need to check for enableIfAttribute EditorGUILayout.PropertyField(property, label, includeChildren); } } }
protected override void OnGUI_Internal(Rect rect, SerializedProperty property, GUIContent label) { EditorGUI.BeginProperty(rect, label, property); if (property.propertyType == SerializedPropertyType.ObjectReference) { Rect propertyRect = new Rect() { x = rect.x, y = rect.y, width = rect.width, height = EditorGUIUtility.singleLineHeight }; EditorGUI.PropertyField(propertyRect, property, label); Texture2D previewTexture = GetAssetPreview(property); if (previewTexture != null) { var previewAttribute = PropertyUtility.GetAttribute <ShowAssetPreviewAttribute>(property); var previewSize = GetAssetPreviewSize(property, previewAttribute); var previewPosition = rect.x + NaughtyEditorGUI.GetIndentLength(rect); switch (previewAttribute.Alignment) { case TextAlignment.Center: previewPosition += (rect.width - previewSize.x) / 2; break; case TextAlignment.Right: previewPosition = rect.max.x - previewSize.x; break; } Rect previewRect = new Rect { x = previewPosition, y = rect.y + EditorGUIUtility.singleLineHeight, width = rect.width, height = previewSize.y }; GUI.Label(previewRect, previewTexture); } } else { string message = property.name + " doesn't have an asset preview"; DrawDefaultPropertyAndHelpBox(rect, property, message, MessageType.Warning); } EditorGUI.EndProperty(); }
protected override void OnGUI_Internal(Rect rect, SerializedProperty property, GUIContent label) { EditorGUI.BeginProperty(rect, label, property); if (!IsNumber(property)) { string message = string.Format("Field {0} is not a number", property.name); DrawDefaultPropertyAndHelpBox(rect, property, message, MessageType.Warning); return; } if (_cachedProgressBarAttribute == null) { _cachedProgressBarAttribute = PropertyUtility.GetAttribute <ProgressBarAttribute>(property); } ProgressBarAttribute progressBarAttribute = _cachedProgressBarAttribute; var value = property.propertyType == SerializedPropertyType.Integer ? property.intValue : property.floatValue; var valueFormatted = property.propertyType == SerializedPropertyType.Integer ? value.ToString() : string.Format("{0:0.00}", value); var maxValue = GetMaxValue(property, progressBarAttribute); if (maxValue != null && IsNumber(maxValue)) { var fillPercentage = value / CastToFloat(maxValue); var barLabel = (!string.IsNullOrEmpty(progressBarAttribute.Name) ? "[" + progressBarAttribute.Name + "] " : "") + valueFormatted + "/" + maxValue; var barColor = progressBarAttribute.Color.GetColor(); var labelColor = Color.white; var indentLength = NaughtyEditorGUI.GetIndentLength(rect); Rect barRect = new Rect() { x = rect.x + indentLength, y = rect.y, width = rect.width - indentLength, height = EditorGUIUtility.singleLineHeight }; DrawBar(barRect, Mathf.Clamp01(fillPercentage), barLabel, barColor, labelColor); } else { string message = string.Format( "The provided dynamic max value for the progress bar is not correct. Please check if the '{0}' is correct, or the return type is float/int", nameof(progressBarAttribute.MaxValueName)); DrawDefaultPropertyAndHelpBox(rect, property, message, MessageType.Warning); } EditorGUI.EndProperty(); }
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 ValidateProperty(SerializedProperty property) { if (_cachedMaxValueAttribute == null) { _cachedMaxValueAttribute = PropertyUtility.GetAttribute <MaxValueAttribute>(property); } MaxValueAttribute maxValueAttribute = _cachedMaxValueAttribute; if (property.propertyType == SerializedPropertyType.Integer) { if (property.intValue > maxValueAttribute.MaxValue) { property.intValue = (int)maxValueAttribute.MaxValue; } } else if (property.propertyType == SerializedPropertyType.Float) { if (property.floatValue > maxValueAttribute.MaxValue) { property.floatValue = maxValueAttribute.MaxValue; } } else if (property.propertyType == SerializedPropertyType.Vector2) { property.vector2Value = Vector2.Min(property.vector2Value, new Vector2(maxValueAttribute.MaxValue, maxValueAttribute.MaxValue)); } else if (property.propertyType == SerializedPropertyType.Vector3) { property.vector3Value = Vector3.Min(property.vector3Value, new Vector3(maxValueAttribute.MaxValue, maxValueAttribute.MaxValue, maxValueAttribute.MaxValue)); } else if (property.propertyType == SerializedPropertyType.Vector4) { property.vector4Value = Vector4.Min(property.vector4Value, new Vector4(maxValueAttribute.MaxValue, maxValueAttribute.MaxValue, maxValueAttribute.MaxValue, maxValueAttribute.MaxValue)); } else if (property.propertyType == SerializedPropertyType.Vector2Int) { property.vector2IntValue = Vector2Int.Min(property.vector2IntValue, new Vector2Int((int)maxValueAttribute.MaxValue, (int)maxValueAttribute.MaxValue)); } else if (property.propertyType == SerializedPropertyType.Vector3Int) { property.vector3IntValue = Vector3Int.Min(property.vector3IntValue, new Vector3Int((int)maxValueAttribute.MaxValue, (int)maxValueAttribute.MaxValue, (int)maxValueAttribute.MaxValue)); } else { string warning = maxValueAttribute.GetType().Name + " can be used only on int, float, Vector or VectorInt fields"; Debug.LogWarning(warning, property.serializedObject.targetObject); } }
protected override void OnGUI_Internal(Rect rect, SerializedProperty property, GUIContent label) { EditorGUI.BeginProperty(rect, label, property); if (_cachedAnimatorParamAttribute == null) { _cachedAnimatorParamAttribute = PropertyUtility.GetAttribute <AnimatorParamAttribute>(property); } AnimatorParamAttribute animatorParamAttribute = _cachedAnimatorParamAttribute; AnimatorController animatorController = _cachedAnimatorController; if (animatorController == null) { DrawDefaultPropertyAndHelpBox(rect, property, InvalidAnimatorControllerWarningMessage, MessageType.Warning); return; } int parametersCount = animatorController.parameters.Length; List <AnimatorControllerParameter> animatorParameters = new List <AnimatorControllerParameter>(parametersCount); for (int i = 0; i < parametersCount; i++) { AnimatorControllerParameter parameter = animatorController.parameters[i]; if (animatorParamAttribute.AnimatorParamType == null || parameter.type == animatorParamAttribute.AnimatorParamType) { animatorParameters.Add(parameter); } } switch (property.propertyType) { case SerializedPropertyType.Integer: DrawPropertyForInt(rect, property, label, animatorParameters); break; case SerializedPropertyType.String: DrawPropertyForString(rect, property, label, animatorParameters); break; default: DrawDefaultPropertyAndHelpBox(rect, property, string.Format(InvalidTypeWarningMessage, property.name), MessageType.Warning); break; } EditorGUI.EndProperty(); }