private Vector2 GetAssetPreviewSize(SerializedProperty property) { Texture2D previewTexture = GetAssetPreview(property); if (previewTexture == null) { return(Vector2.zero); } else { int targetWidth = ShowAssetPreviewAttribute.DefaultWidth; int targetHeight = ShowAssetPreviewAttribute.DefaultHeight; ShowAssetPreviewAttribute showAssetPreviewAttribute = PropertyUtility.GetAttribute <ShowAssetPreviewAttribute>(property); 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)); } }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { TooltipAttribute tooltip = PropertyUtility.GetAttribute <TooltipAttribute>(property); label.tooltip = tooltip?.tooltip; EditorGUI.PropertyField(position, property.FindPropertyRelative("_length"), label); }
protected override void OnGUI_Internal(Rect rect, SerializedProperty property, GUIContent label) { QuadraticSliderAttribute quadraticAttribute = PropertyUtility.GetAttribute <QuadraticSliderAttribute>(property); if (quadraticAttribute != null) { NonLinearSliderDrawer.Draw(rect, property, quadraticAttribute.Min, quadraticAttribute.Max, GetQuadraticFunction(quadraticAttribute.Power), label); } }
protected override float GetPropertyHeight_Internal(SerializedProperty property, GUIContent label) { ProgressBarAttribute progressBarAttribute = PropertyUtility.GetAttribute <ProgressBarAttribute>(property); var maxValue = GetMaxValue(property, progressBarAttribute); return(IsNumber(property) && maxValue is float ?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)); }
protected override void OnGUI_Internal(Rect rect, SerializedProperty property, GUIContent label) { if (property.hasChildren) { InlineAttribute attribute = PropertyUtility.GetAttribute <InlineAttribute>(property); if (attribute.ShowHeaderAndBox) { rect.position += new Vector2(0, EditorGUIUtility.singleLineHeight * 0.2f); EditorGUI.LabelField(rect, label, EditorStyles.boldLabel); NaughtyEditorGUI.BeginBoxGroup_Layout(); } //Move to first child SerializedProperty child = property.Copy(); child.Next(true); SerializedProperty endProperty = property.GetEndProperty(true); bool enterChildren; if (attribute.ShowHeaderAndBox) { enterChildren = EditorGUILayout.PropertyField(child); } else { enterChildren = EditorGUI.PropertyField(rect, child); } while (child.Next(enterChildren) && !SerializedProperty.EqualContents(child, endProperty)) { enterChildren = EditorGUILayout.PropertyField(child); } if (attribute.ShowHeaderAndBox) { NaughtyEditorGUI.EndBoxGroup_Layout(); } } else { EditorGUILayout.PropertyField(property); NaughtyEditorGUI.HelpBox_Layout("Can't use [Inline] on a property with no children.", MessageType.Warning); } }
/// <summary> /// Tries to find the member property. Not guaranteed to find one, as the given name (or auto name) could be wrong. /// </summary> static PropertyInfo FindProperty(SerializedProperty serializedProperty) { UsePropertySetterAttribute attribute = PropertyUtility.GetAttribute <UsePropertySetterAttribute>(serializedProperty); string propertyName; if (attribute.autoFindProperty) { propertyName = serializedProperty.displayName.Replace(" ", string.Empty); } else { propertyName = attribute.propertyName; } Object targetObject = serializedProperty.serializedObject.targetObject; return(ReflectionUtility.GetProperty(targetObject, propertyName)); }
public override void OnInspectorGUI() { GetSerializedProperties(ref _serializedProperties); bool anyNaughtyAttribute = _serializedProperties.Any(p => PropertyUtility.GetAttribute <INaughtyAttribute>(p) != null); if (!anyNaughtyAttribute) { DrawDefaultInspector(); } else { DrawSerializedProperties(); } DrawNonSerializedFields(); DrawNativeProperties(); DrawButtons(); }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { MinMaxRange.SliderAttribute attribute = PropertyUtility.GetAttribute <MinMaxRange.SliderAttribute>(property); if (attribute != null) { Draw(position, property, attribute.min, attribute.max, label); } else { EditorGUI.PropertyField(position, property, label); if (property.isExpanded) { EditorGUI.indentLevel++; NaughtyEditorGUI.HelpBox_Layout("MinMaxRange needs a [MinMaxRange.Slider(min, max)] attribute for the fancy editor.", MessageType.Info); EditorGUI.indentLevel--; } } }
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; } var attribute = PropertyUtility.GetAttribute <CurveRangeAttribute>(property); 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)); EditorGUI.EndProperty(); }
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 maxValue = GetMaxValue(property, progressBarAttribute); if (maxValue != null && maxValue is float) { var fillPercentage = value / (float)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", nameof(progressBarAttribute.MaxValueName)); DrawDefaultPropertyAndHelpBox(rect, property, message, MessageType.Warning); } }
protected override void OnGUI_Internal(Rect rect, SerializedProperty property, GUIContent label) { AnimatorParamAttribute animatorParamAttribute = PropertyUtility.GetAttribute <AnimatorParamAttribute>(property); AnimatorController animatorController = GetAnimatorController(property, animatorParamAttribute.AnimatorName); 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; } }
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; } 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 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"; Debug.LogWarning(warning, property.serializedObject.targetObject); } }
private static IEnumerable <IGrouping <string, SerializedProperty> > GetFoldoutProperties(IEnumerable <SerializedProperty> properties) { return(properties .Where(p => PropertyUtility.GetAttribute <FoldoutAttribute>(p) != null) .GroupBy(p => PropertyUtility.GetAttribute <FoldoutAttribute>(p).Name)); }
/// <summary> /// Takes a SerializedProperty and finds a local component that can be slotted into it. /// Local in this context means its a component attached to the same GameObject. /// This could easily be changed to use GetComponentInParent/GetComponentInChildren /// </summary> /// <param name="property"></param> /// <returns></returns> private Component FindAutohookTarget(SerializedProperty property) { var root = property.serializedObject; if (root.targetObject is Component) { // first, lets find the type of component were trying to autohook... var type = GetTypeFromProperty(property); if (type == null) { return(null); } // ...then use GetComponent(type) to see if there is one on our object. var component = (Component)root.targetObject; Component ret = component.GetComponent(type); if (ret != null) { return(ret); } AutohookAttribute autohookAttribute = PropertyUtility.GetAttribute <AutohookAttribute>(property); switch (autohookAttribute.Mode) { case AutohookAttribute.AutohookMode.AlsoChildren: return(component.GetComponentInChildren(type)); case AutohookAttribute.AutohookMode.AlsoParent: return(component.GetComponentInParent(type)); case AutohookAttribute.AutohookMode.AllParents: { Transform t = component.transform.parent; while (t != null) { ret = t.GetComponent(type); if (ret != null) { return(ret); } t = t.parent; } return(null); } case AutohookAttribute.AutohookMode.SiblingsAndChildren: { return(component.transform.parent?.GetComponentInChildren(type)); } case AutohookAttribute.AutohookMode.UpwardsAllChildren: { Transform t = component.transform.parent; while (t != null) { ret = t.GetComponentInChildren(type); if (ret != null) { return(ret); } t = t.parent; } return(null); } } return(ret); } else { Debug.Log("OH NO handle fails here better pls"); } return(null); }
public sealed override PropertyCondition OnGuiValidate(SerializedProperty property) { return(OnGuiValidate(property, PropertyUtility.GetAttribute <T>(property))); }
private static IEnumerable <SerializedProperty> GetNonGroupedProperties(IEnumerable <SerializedProperty> properties) { return(properties.Where(p => PropertyUtility.GetAttribute <IGroupAttribute>(p) == null)); }
bool ShouldUseEnumKeys(SerializedProperty property) { return(keyType.IsEnum && PropertyUtility.GetAttribute <EnumKeysAttribute>(property) != null); }
public override void ValidateProperty(SerializedProperty property) { ValidateInputAttribute validateInputAttribute = PropertyUtility.GetAttribute <ValidateInputAttribute>(property); object target = PropertyUtility.GetTargetObjectWithProperty(property); MethodInfo validationCallback = ReflectionUtility.GetMethod(target, validateInputAttribute.CallbackName); if (validationCallback != null && validationCallback.ReturnType == typeof(bool)) { ParameterInfo[] callbackParameters = validationCallback.GetParameters(); if (callbackParameters.Length == 0) { if (!(bool)validationCallback.Invoke(target, null)) { if (string.IsNullOrEmpty(validateInputAttribute.Message)) { NaughtyEditorGUI.HelpBox_Layout( property.name + " is not valid", MessageType.Error, context: property.serializedObject.targetObject); } else { NaughtyEditorGUI.HelpBox_Layout( validateInputAttribute.Message, MessageType.Error, context: property.serializedObject.targetObject); } } } else if (callbackParameters.Length == 1) { FieldInfo fieldInfo = ReflectionUtility.GetField(target, property.name); Type fieldType = fieldInfo.FieldType; Type parameterType = callbackParameters[0].ParameterType; if (fieldType == parameterType) { if (!(bool)validationCallback.Invoke(target, new object[] { fieldInfo.GetValue(target) })) { if (string.IsNullOrEmpty(validateInputAttribute.Message)) { NaughtyEditorGUI.HelpBox_Layout( property.name + " is not valid", MessageType.Error, context: property.serializedObject.targetObject); } else { NaughtyEditorGUI.HelpBox_Layout( validateInputAttribute.Message, MessageType.Error, context: property.serializedObject.targetObject); } } } else { string warning = "The field type is not the same as the callback's parameter type"; NaughtyEditorGUI.HelpBox_Layout(warning, MessageType.Warning, context: property.serializedObject.targetObject); } } else { string warning = validateInputAttribute.GetType().Name + " needs a callback with boolean return type and an optional single parameter of the same type as the field"; NaughtyEditorGUI.HelpBox_Layout(warning, MessageType.Warning, context: property.serializedObject.targetObject); } } }
public override sealed void OnGui(SerializedProperty property, GUIContent label) { OnGui(property, label, PropertyUtility.GetAttribute <T>(property)); }