public override Bounds BoundsField(GUIContent content, Bounds value, Layout option) { return(EditorGUILayout.BoundsField(content, value, option)); }
public static bool DrawLayoutField(object value, string label) { GUI.enabled = false; bool isDrawn = false; Type valueType = value.GetType(); if (valueType == typeof(int)) { isDrawn = true; EditorGUILayout.IntField(label, (int)value); } else if (valueType == typeof(long)) { isDrawn = true; EditorGUILayout.LongField(label, (long)value); } else if (valueType == typeof(float)) { isDrawn = true; EditorGUILayout.FloatField(label, (float)value); } else if (valueType == typeof(double)) { isDrawn = true; EditorGUILayout.DoubleField(label, (double)value); } else if (valueType == typeof(string)) { isDrawn = true; EditorGUILayout.TextField(label, (string)value); } else if (valueType == typeof(Vector2)) { isDrawn = true; EditorGUILayout.Vector2Field(label, (Vector2)value); } else if (valueType == typeof(Vector3)) { isDrawn = true; EditorGUILayout.Vector3Field(label, (Vector3)value); } else if (valueType == typeof(Vector4)) { isDrawn = true; EditorGUILayout.Vector4Field(label, (Vector4)value); } else if (valueType == typeof(Color)) { isDrawn = true; EditorGUILayout.ColorField(label, (Color)value); } else if (valueType == typeof(Bounds)) { isDrawn = true; EditorGUILayout.BoundsField(label, (Bounds)value); } else if (valueType == typeof(Rect)) { isDrawn = true; EditorGUILayout.RectField(label, (Rect)value); } else { isDrawn = false; } GUI.enabled = true; return(isDrawn); }
public static object DrawIndividualVariable(ComponentDescription componentDescription, WrappedVariable variable, string fieldName, Type fieldType, object fieldValue, Action <Guid, WrappedVariable> onObjectPicker) { object newValue; if (variable.DataType == DataType.Enum) { newValue = EditorGUILayout.IntPopup(fieldName, (int)fieldValue, variable.MetaData.EnumNames, variable.MetaData.EnumValues); } else if (variable.DataType == DataType.UnityObjectReference) { if (fieldValue is Guid) { EditorGUILayout.BeginHorizontal(); EditorGUILayout.PrefixLabel(fieldName); if ((Guid)fieldValue != Guid.Empty) { EditorGUILayout.TextField(variable.MetaData.ValueDisplayName); } else { EditorGUILayout.TextField("None (" + variable.MetaData.TypeFullName + ")"); } if (componentDescription != null) { if (GUILayout.Button("...", GUILayout.Width(30))) { onObjectPicker(componentDescription.Guid, variable); } } EditorGUILayout.EndHorizontal(); newValue = fieldValue; } else if (typeof(UnityEngine.Object).IsAssignableFrom(fieldType)) { newValue = EditorGUILayout.ObjectField(fieldName, (UnityEngine.Object)fieldValue, variable.MetaData.GetTypeFromMetaData(), true); } else { throw new NotSupportedException(); } } else if (fieldType == typeof(int) || (fieldType.IsSubclassOf(typeof(Enum)) && OldInspectorSidekick.Current.Settings.TreatEnumsAsInts)) { newValue = EditorGUILayout.IntField(fieldName, (int)fieldValue); } else if (fieldType == typeof(long)) { newValue = EditorGUILayout.LongField(fieldName, (long)fieldValue); } else if (fieldType == typeof(string)) { newValue = EditorGUILayout.TextField(fieldName, (string)fieldValue); } else if (fieldType == typeof(char)) { string newString = EditorGUILayout.TextField(fieldName, new string((char)fieldValue, 1)); if (newString.Length == 1) { newValue = newString[0]; } else { newValue = fieldValue; } } else if (fieldType == typeof(float)) { newValue = EditorGUILayout.FloatField(fieldName, (float)fieldValue); } else if (fieldType == typeof(double)) { newValue = EditorGUILayout.DoubleField(fieldName, (double)fieldValue); } else if (fieldType == typeof(bool)) { newValue = EditorGUILayout.Toggle(fieldName, (bool)fieldValue); } else if (fieldType == typeof(Vector2)) { newValue = EditorGUILayout.Vector2Field(fieldName, (Vector2)fieldValue); } else if (fieldType == typeof(Vector3)) { newValue = EditorGUILayout.Vector3Field(fieldName, (Vector3)fieldValue); } else if (fieldType == typeof(Vector4)) { newValue = EditorGUILayout.Vector4Field(fieldName, (Vector4)fieldValue); } #if UNITY_2017_2_OR_NEWER else if (fieldType == typeof(Vector2Int)) { newValue = EditorGUILayout.Vector2IntField(fieldName, (Vector2Int)fieldValue); } else if (fieldType == typeof(Vector3Int)) { newValue = EditorGUILayout.Vector3IntField(fieldName, (Vector3Int)fieldValue); } #endif else if (fieldType == typeof(Quaternion)) { //if(InspectorSidekick.Current.Settings.RotationsAsEuler) //{ // Quaternion quaternion = (Quaternion)fieldValue; // Vector3 eulerAngles = quaternion.eulerAngles; // eulerAngles = EditorGUILayout.Vector3Field(fieldName, eulerAngles); // newValue = Quaternion.Euler(eulerAngles); //} //else { Quaternion quaternion = (Quaternion)fieldValue; Vector4 vector = new Vector4(quaternion.x, quaternion.y, quaternion.z, quaternion.w); vector = EditorGUILayout.Vector4Field(fieldName, vector); newValue = new Quaternion(vector.x, vector.y, vector.z, vector.z); } } else if (fieldType == typeof(Bounds)) { newValue = EditorGUILayout.BoundsField(fieldName, (Bounds)fieldValue); } #if UNITY_2017_2_OR_NEWER else if (fieldType == typeof(BoundsInt)) { newValue = EditorGUILayout.BoundsIntField(fieldName, (BoundsInt)fieldValue); } #endif else if (fieldType == typeof(Color)) { newValue = EditorGUILayout.ColorField(fieldName, (Color)fieldValue); } else if (fieldType == typeof(Color32)) { newValue = (Color32)EditorGUILayout.ColorField(fieldName, (Color32)fieldValue); } else if (fieldType == typeof(Gradient)) { newValue = InternalEditorGUILayout.GradientField(new GUIContent(fieldName), (Gradient)fieldValue); } else if (fieldType == typeof(AnimationCurve)) { newValue = EditorGUILayout.CurveField(fieldName, (AnimationCurve)fieldValue); } else if (fieldType.IsSubclassOf(typeof(Enum))) { newValue = EditorGUILayout.EnumPopup(fieldName, (Enum)fieldValue); } else if (fieldType == typeof(Rect)) { newValue = EditorGUILayout.RectField(fieldName, (Rect)fieldValue); } #if UNITY_2017_2_OR_NEWER else if (fieldType == typeof(RectInt)) { newValue = EditorGUILayout.RectIntField(fieldName, (RectInt)fieldValue); } #endif else if (fieldType.IsSubclassOf(typeof(UnityEngine.Object))) { newValue = EditorGUILayout.ObjectField(fieldName, (UnityEngine.Object)fieldValue, fieldType, true); } else { GUILayout.Label(fieldType + " " + fieldName); newValue = fieldValue; } // EditorGUILayout.BoundsField() // EditorGUILayout.ColorField // EditorGUILayout.CurveField // EditorGUILayout.EnumPopup // EditorGUILayout.EnumMaskField // EditorGUILayout.IntSlider // If there's a range attribute maybe? // EditorGUILayout.LabelField // what's this? // EditorGUILayout.ObjectField // EditorGUILayout.RectField // EditorGUILayout.TextArea // EditorGUILayout.TextField // What's this? public static void HelpBox (string message, MessageType type, bool wide) // What's this? public static bool InspectorTitlebar (bool foldout, Object targetObj) return(newValue); }
public object DrawAndGetNewValue(Type memberType, string memberName, object value, IEntity entity, int index, IComponent component) { return(EditorGUILayout.BoundsField(memberName, (Bounds)value)); }
/// <summary> /// /// </summary> /// <returns></returns> protected override Bounds DrawAndUpdateValue() { return(EditorGUILayout.BoundsField(new GUIContent(Label), m_cachedValue, options)); }
///Draws an Editor field for object of type directly public static object DrawEditorFieldDirect(GUIContent content, object value, Type t, FieldInfo field = null, object context = null, object[] attributes = null) { if (typeof(UnityObject).IsAssignableFrom(t) == false && t != typeof(Type)) { //Check abstract if ((value != null && value.GetType().IsAbstract) || (value == null && t.IsAbstract)) { EditorGUILayout.LabelField(content, new GUIContent(string.Format("Abstract ({0})", t.FriendlyName()))); return(value); } //Auto create instance for some types if (value == null && t != typeof(object) && !t.IsAbstract && !t.IsInterface) { if (t.GetConstructor(Type.EmptyTypes) != null || t.IsArray) { if (t.IsArray) { value = Array.CreateInstance(t.GetElementType(), 0); } else { value = Activator.CreateInstance(t); } } } } //Check the type if (typeof(UnityObject).IsAssignableFrom(t)) { if (t == typeof(Component) && (value is Component)) { return(ComponentField(content, (Component)value, typeof(Component))); } return(EditorGUILayout.ObjectField(content, (UnityObject)value, t, true)); } if (t == typeof(Type)) { return(Popup <Type>(content, (Type)value, UserTypePrefs.GetPreferedTypesList(true))); } if (t == typeof(string)) { return(EditorGUILayout.TextField(content, (string)value)); } if (t == typeof(char)) { var c = (char)value; var s = c.ToString(); s = EditorGUILayout.TextField(content, s); return(string.IsNullOrEmpty(s)? (char)c : (char)s[0]); } if (t == typeof(bool)) { return(EditorGUILayout.Toggle(content, (bool)value)); } if (t == typeof(int)) { return(EditorGUILayout.IntField(content, (int)value)); } if (t == typeof(float)) { return(EditorGUILayout.FloatField(content, (float)value)); } if (t == typeof(byte)) { return(Convert.ToByte(Mathf.Clamp(EditorGUILayout.IntField(content, (byte)value), 0, 255))); } if (t == typeof(Vector2)) { return(EditorGUILayout.Vector2Field(content, (Vector2)value)); } if (t == typeof(Vector3)) { return(EditorGUILayout.Vector3Field(content, (Vector3)value)); } if (t == typeof(Vector4)) { return(EditorGUILayout.Vector4Field(content, (Vector4)value)); } if (t == typeof(Quaternion)) { var quat = (Quaternion)value; var vec4 = new Vector4(quat.x, quat.y, quat.z, quat.w); vec4 = EditorGUILayout.Vector4Field(content, vec4); return(new Quaternion(vec4.x, vec4.y, vec4.z, vec4.w)); } if (t == typeof(Color)) { return(EditorGUILayout.ColorField(content, (Color)value)); } if (t == typeof(Rect)) { return(EditorGUILayout.RectField(content, (Rect)value)); } if (t == typeof(AnimationCurve)) { return(EditorGUILayout.CurveField(content, (AnimationCurve)value)); } if (t == typeof(Bounds)) { return(EditorGUILayout.BoundsField(content, (Bounds)value)); } if (t == typeof(LayerMask)) { return(LayerMaskField(content, (LayerMask)value)); } if (t.IsSubclassOf(typeof(System.Enum))) { if (t.IsDefined(typeof(FlagsAttribute), true)) { return(EditorGUILayout.EnumMaskPopup(content, (System.Enum)value)); } return(EditorGUILayout.EnumPopup(content, (System.Enum)value)); } if (typeof(IList).IsAssignableFrom(t)) { return(ListEditor(content, (IList)value, t, field, context, attributes)); } if (typeof(IDictionary).IsAssignableFrom(t)) { return(DictionaryEditor(content, (IDictionary)value, t, field, context, attributes)); } //show nested class members recursively if (value != null && (t.IsClass || t.IsValueType)) { if (EditorGUI.indentLevel <= 8) { GUILayout.BeginVertical(); EditorGUILayout.LabelField(content, new GUIContent(string.Format("({0})", t.FriendlyName()))); EditorGUI.indentLevel++; ReflectedObjectInspector(value); EditorGUI.indentLevel--; GUILayout.EndVertical(); } } else { EditorGUILayout.LabelField(content, new GUIContent(string.Format("NonInspectable ({0})", t.FriendlyName()))); } return(value); }
public static object GUISwitch(string type, object value) { var tmp = value; switch (type) { case "AnimationCurve": return(SetValueGUI(EditorGUILayout.CurveField(GetValue <AnimationCurve>(value)), tmp)); case "Bounds": return(SetValueGUI(EditorGUILayout.BoundsField(GetValue <Bounds>(value)), tmp)); case "BoundsInt": return(SetValueGUI(EditorGUILayout.BoundsIntField(GetValue <BoundsInt>(value)), tmp)); case "Color": return(SetValueGUI(EditorGUILayout.ColorField(GetValue <Color>(value)), tmp)); case "Color32": return(SetValueGUI(EditorGUILayout.ColorField(GetValue <Color32>(value)), tmp)); case "Double": return(SetValueGUI(EditorGUILayout.DoubleField(GetValue <double>(value)), tmp)); case "Enum": return(SetValueGUI(EditorGUILayout.EnumPopup(GetValue <Enum>(value)), tmp)); case "Single": return(SetValueGUI(EditorGUILayout.FloatField(GetValue <float>(value)), tmp)); case "Gradient": return(SetValueGUI(EditorGUILayout.GradientField(GetValue <Gradient>(value)), tmp)); case "Rect": return(SetValueGUI(EditorGUILayout.RectField(GetValue <Rect>(value)), tmp)); case "RectInt": return(SetValueGUI(EditorGUILayout.RectIntField(GetValue <RectInt>(value)), tmp)); case "String": return(SetValueGUI(EditorGUILayout.TextField(GetValue <string>(value)), tmp)); case "Boolean": return(SetValueGUI(EditorGUILayout.Toggle(GetValue <bool>(value)), tmp)); case "Vector2": return(SetValueGUI(EditorGUILayout.Vector2Field("", GetValue <Vector2>(value)), tmp)); case "Vector2Int": return(SetValueGUI(EditorGUILayout.Vector2IntField("", GetValue <Vector2Int>(value)), tmp)); case "Vector3": return(SetValueGUI(EditorGUILayout.Vector3Field("", GetValue <Vector3>(value)), tmp)); case "Vector3Int": return(SetValueGUI(EditorGUILayout.Vector3IntField("", GetValue <Vector3Int>(value)), tmp)); case "Vector4": return(SetValueGUI(EditorGUILayout.Vector4Field("", GetValue <Vector4>(value)), tmp)); case "Quaternion": return(SetValueGUI(EditorGUILayout.Vector4Field("", GetValue <Quaternion>(value).GetVector4()).GetQuaternion(), tmp)); //All Integer Types case "Byte": case "Int16": case "Int32": case "SByte": case "UInt16": case "UInt32": return(SetValueGUI(EditorGUILayout.IntField(GetValue <int>(value)), tmp)); case "UInt64": case "Int64": return(SetValueGUI(EditorGUILayout.LongField(GetValue <long>(value)), tmp)); // } return(new object()); }
public static object GetUnityEditorInputFieldValue(this Type type, object currentValue) { if (type.IsSubtypeOrEqualToOneOf(typeof(int), typeof(short), typeof(byte))) { return(EditorGUILayout.IntField((int)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(long))) { return(EditorGUILayout.LongField((long)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(float))) { return(EditorGUILayout.FloatField((float)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(double))) { return(EditorGUILayout.DoubleField((double)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(string))) { return(EditorGUILayout.TextField(((string)currentValue) ?? "")); } else if (type.IsSubtypeOrEqualTo(typeof(char))) { return(CharField((char)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(bool))) { return(EditorGUILayout.Toggle((bool)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(Enum))) { return(EnumField(type, currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(Color))) { return(EditorGUILayout.ColorField((Color)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(LayerMask))) { return(LayerMaskField((LayerMask)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(Vector2))) { return(EditorGUILayout.Vector2Field("", (Vector2)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(Vector3))) { return(EditorGUILayout.Vector3Field("", (Vector3)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(Vector4))) { return(EditorGUILayout.Vector4Field("", (Vector4)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(Rect))) { return(EditorGUILayout.RectField((Rect)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(Bounds))) { return(EditorGUILayout.BoundsField((Bounds)currentValue)); } else if (type.IsSubtypeOrEqualTo(typeof(AnimationCurve))) { return(EditorGUILayout.CurveField(((AnimationCurve)currentValue) ?? new AnimationCurve())); } else if (type.IsSubtypeOrEqualTo(typeof(UnityEngine.Object))) { return(ObjectField(type, (UnityEngine.Object)currentValue)); } throw new ArgumentException(string.Format("type {0} has no Unity Editor input field", type), "type"); }
public void WizardGUI() { int size = 0; try { size = Method.Parameters.Count; } catch (NullReferenceException) { EditorGUILayout.HelpBox("My parent window has lost focus, please close me", MessageType.Error); return; } for (int i = 0; i < size; i++) { var parameter = Method.Parameters[i]; switch (parameter.TypeName) { case "String": parameter.StringValue = EditorGUILayout.TextField(parameter.DisplayName, parameter.StringValue); break; case "Int32": parameter.IntValue = EditorGUILayout.IntField(parameter.DisplayName, parameter.IntValue); break; case "Int64": parameter.LongValue = EditorGUILayout.LongField(parameter.DisplayName, parameter.LongValue); break; case "Single": parameter.FloatValue = EditorGUILayout.FloatField(parameter.DisplayName, parameter.FloatValue); break; case "Double": parameter.DoubleValue = EditorGUILayout.DoubleField(parameter.DisplayName, parameter.DoubleValue); break; case "Boolean": parameter.BoolValue = EditorGUILayout.Toggle(parameter.DisplayName, parameter.BoolValue); break; case "Vector2": parameter.Vector2Value = EditorGUILayout.Vector2Field(parameter.DisplayName, parameter.Vector2Value); break; case "Vector3": parameter.Vector3Value = EditorGUILayout.Vector3Field(parameter.DisplayName, parameter.Vector3Value); break; case "Vector4": parameter.Vector4Value = EditorGUILayout.Vector4Field(parameter.DisplayName, parameter.Vector4Value); break; case "Quaternion": var v4 = new Vector4(parameter.QuaternionValue.x, parameter.QuaternionValue.y, parameter.QuaternionValue.z, parameter.QuaternionValue.w); v4 = EditorGUILayout.Vector4Field(parameter.DisplayName, v4); parameter.QuaternionValue = new Quaternion(v4.x, v4.y, v4.z, v4.w); break; case "Bounds": parameter.BoundsValue = EditorGUILayout.BoundsField(parameter.DisplayName, parameter.BoundsValue); break; case "Rect": parameter.RectValue = EditorGUILayout.RectField(parameter.DisplayName, parameter.RectValue); break; case "Matrix4x4": matrixMode = (MatrixWizard.EMatrixMode)EditorGUILayout.EnumPopup(parameter.DisplayName, matrixMode); switch (matrixMode) { case MatrixWizard.EMatrixMode.Column: parameter.MatrixValue = MatrixWizard.DrawColumns(parameter.MatrixValue); break; case MatrixWizard.EMatrixMode.Row: parameter.MatrixValue = MatrixWizard.DrawRows(parameter.MatrixValue); break; } break; case "AnimationCurve": parameter.AnimationCurveValue = EditorGUILayout.CurveField(parameter.AnimationCurveValue); break; case "Object": case "GameObject": parameter.ObjectValue = EditorGUILayout.ObjectField(parameter.DisplayName, parameter.ObjectValue, parameter.Type, true); break; case "Enum": var enumValue = (Enum)Enum.Parse(parameter.Type, parameter.EnumNames[parameter.EnumValue]); enumValue = EditorGUILayout.EnumPopup(parameter.DisplayName, enumValue); for (int j = 0; j < parameter.EnumNames.Length; j++) { if (parameter.EnumNames[j] == enumValue.ToString()) { parameter.EnumValue = j; break; } } break; default: EditorGUILayout.HelpBox(string.Format("The type {0} is not supported", parameter.RepresentableType), MessageType.Warning); break; } } }
public void ShowInternalItem_Playing(string path, string key, object value, bool showKey = true) { if (value == null) { return; } var type = value.GetType(); bool endSingleVertical = false; if (showKey) { if (type.IsValueType || type == typeof(string) || type.IsSubclassOf(typeof(UnityEngine.Object)) || type == typeof(UnityEngine.Object)) { EditorGUILayout.BeginHorizontal(); EditorGUILayout.PrefixLabel(GetPrefixKey(key)); endSingleVertical = true; } } if (type.IsValueType) { if (type == typeof(double)) { EditorGUILayout.DoubleField((double)value); } else if (type == typeof(bool)) { EditorGUILayout.Toggle((bool)value); } else if (type == typeof(System.Int32)) { EditorGUILayout.IntField(System.Convert.ToInt32(value)); } else if (type == typeof(System.Int64)) { EditorGUILayout.IntField(System.Convert.ToInt32(value)); } else if (type == typeof(System.Double)) { EditorGUILayout.DoubleField(System.Convert.ToDouble(value)); } else if (type == typeof(System.Single)) { EditorGUILayout.FloatField(System.Convert.ToSingle(value)); } else if (type == typeof(Vector2)) { EditorGUILayout.Vector2Field(string.Empty, (Vector2)value); } else if (type == typeof(Vector3)) { EditorGUILayout.Vector3Field(string.Empty, (Vector3)value); } else if (type == typeof(Vector4)) { EditorGUILayout.Vector4Field(string.Empty, (Vector4)value); } else if (type == typeof(Color)) { EditorGUILayout.ColorField((Color)value); } else if (type == typeof(Rect)) { EditorGUILayout.RectField((Rect)value); } else if (type == typeof(Bounds)) { EditorGUILayout.BoundsField((Bounds)value); } else if (type.IsSubclassOf(typeof(System.Enum))) { EditorGUILayout.EnumPopup(value as System.Enum); } } else { if (type == typeof(string)) { EditorGUILayout.TextField(value as string); } else if (type.IsSubclassOf(typeof(UnityEngine.Object)) || type == typeof(UnityEngine.Object)) { EditorGUILayout.ObjectField(value as UnityEngine.Object, type, true); } else if (type.IsArray) { bool show = false; string fullpath = path + "." + key; EditorGUILayout.BeginVertical("Box"); EditorGUI.indentLevel++; foldout.TryGetValue(fullpath, out show); show = EditorGUILayout.Foldout(show, GetPrefixKey(key)); foldout[fullpath] = show; if (show) { var array = value as System.Array; int length = array.Length; for (int i = 0; i < length; i++) { ShowInternalItem_Playing(fullpath, i.ToString(), array.GetValue(i), false); } } EditorGUI.indentLevel--; EditorGUILayout.EndVertical(); } else if (type == typeof(LuaTable)) { bool show = false; string fullpath = null; if (string.IsNullOrEmpty(key)) { show = true; fullpath = key; } else { fullpath = path + "." + key; EditorGUILayout.BeginVertical("Box"); if (!foldout.TryGetValue(fullpath, out show) && string.IsNullOrEmpty(path)) { show = true; } show = EditorGUILayout.Foldout(show, GetPrefixKey(key)); foldout[fullpath] = show; } if (show) { EditorGUI.indentLevel++; LuaTable realValue = value as LuaTable; realValue.ForEach <string, object>((k, v) => { ShowInternalItem_Playing(fullpath, k, v); }); EditorGUI.indentLevel--; } if (!string.IsNullOrEmpty(key)) { EditorGUILayout.EndVertical(); } } } if (endSingleVertical) { EditorGUILayout.EndHorizontal(); } }
void OnGUIForLeftContainer() { // the 330 is from Editor.k_WideModeMinWidth, see InspectorWindow.cs for the code doing it for the IMGUI Inspector. EditorGUIUtility.wideMode = m_IMGUIContainer.layout.width > 330; EditorGUILayout.LabelField("IMGUI Container"); if (m_ShowLabelOnFields) { m_IntegerFieldValue = EditorGUILayout.IntField("IntField", m_IntegerFieldValue); m_LongFieldValue = EditorGUILayout.LongField("LongField", m_LongFieldValue); m_FloatFieldValue = EditorGUILayout.FloatField("FloatField", m_FloatFieldValue); m_DoubleFieldValue = EditorGUILayout.DoubleField("DoubleField", m_DoubleFieldValue); m_EnumValuesFieldValue = (EnumValues)EditorGUILayout.EnumPopup("EnumPopup", m_EnumValuesFieldValue); m_EnumFlagValuesFieldValue = (EnumFlagValues)EditorGUILayout.EnumFlagsField("EnumFlagsField", m_EnumFlagValuesFieldValue); m_TextFieldValue = EditorGUILayout.TextField("TextField", m_TextFieldValue); m_PasswordFieldValue = EditorGUILayout.PasswordField("PasswordField", m_PasswordFieldValue); m_Vector3FieldValue = EditorGUILayout.Vector3Field("Vector3Field", m_Vector3FieldValue); m_Vector3IntFieldValue = EditorGUILayout.Vector3IntField("Vector3IntField", m_Vector3IntFieldValue); m_Vector2FieldValue = EditorGUILayout.Vector2Field("Vector2Field", m_Vector2FieldValue); m_ColorFieldValue = EditorGUILayout.ColorField("ColorField", m_ColorFieldValue); m_CameraObjectFieldValue = EditorGUILayout.ObjectField("ObjectField Camera", m_CameraObjectFieldValue, typeof(Camera), true); m_GameObjectFieldValue = EditorGUILayout.ObjectField("ObjectField GameObj", m_GameObjectFieldValue, typeof(GameObject), true); m_CurveXValue = EditorGUILayout.CurveField("CurveField X", m_CurveXValue); m_CurveMeshValue = EditorGUILayout.CurveField("CurveField Mesh", m_CurveMeshValue); m_PopupFieldValue = EditorGUILayout.Popup("Popup", m_PopupFieldValue, m_PopupFieldOptions); m_RectFieldValue = EditorGUILayout.RectField("RectField", m_RectFieldValue); m_BoundsFieldValue = EditorGUILayout.BoundsField("BoundsField", m_BoundsFieldValue); m_ToggleRightValue = EditorGUILayout.Toggle("Toggle", m_ToggleRightValue); m_MaskFieldValue = EditorGUILayout.MaskField("MaskField", m_MaskFieldValue, m_MaskFieldOptions); m_LayerFieldValue = EditorGUILayout.LayerField("LayerField", m_LayerFieldValue); m_TagFieldValue = EditorGUILayout.TagField("TagField", m_TagFieldValue); EditorGUILayout.MinMaxSlider("MinMaxSlider", ref m_MinMaxSliderMinValue, ref m_MinMaxSliderMaxValue, m_MinMaxSliderMinLimit, m_MinMaxSliderMaxLimit); m_SliderValue = EditorGUILayout.Slider("Slider", m_SliderValue, 2, 8); m_SliderIntValue = EditorGUILayout.IntSlider("IntSlider", m_SliderIntValue, 11, 23); } else { m_IntegerFieldValue = EditorGUILayout.IntField(m_IntegerFieldValue); m_LongFieldValue = EditorGUILayout.LongField(m_LongFieldValue); m_FloatFieldValue = EditorGUILayout.FloatField(m_FloatFieldValue); m_DoubleFieldValue = EditorGUILayout.DoubleField(m_DoubleFieldValue); m_EnumValuesFieldValue = (EnumValues)EditorGUILayout.EnumPopup(m_EnumValuesFieldValue); m_EnumFlagValuesFieldValue = (EnumFlagValues)EditorGUILayout.EnumFlagsField(m_EnumFlagValuesFieldValue); m_TextFieldValue = EditorGUILayout.TextField(m_TextFieldValue); m_PasswordFieldValue = EditorGUILayout.PasswordField(m_PasswordFieldValue); m_Vector3FieldValue = EditorGUILayout.Vector3Field("Vector3Field", m_Vector3FieldValue); m_Vector3IntFieldValue = EditorGUILayout.Vector3IntField("Vector3IntField", m_Vector3IntFieldValue); m_Vector2FieldValue = EditorGUILayout.Vector2Field("Vector2Field", m_Vector2FieldValue); m_ColorFieldValue = EditorGUILayout.ColorField(m_ColorFieldValue); m_CameraObjectFieldValue = EditorGUILayout.ObjectField(m_CameraObjectFieldValue, typeof(Camera), true); m_GameObjectFieldValue = EditorGUILayout.ObjectField(m_GameObjectFieldValue, typeof(GameObject), true); m_CurveXValue = EditorGUILayout.CurveField(m_CurveXValue); m_CurveMeshValue = EditorGUILayout.CurveField(m_CurveMeshValue); m_PopupFieldValue = EditorGUILayout.Popup(m_PopupFieldValue, m_PopupFieldOptions); m_RectFieldValue = EditorGUILayout.RectField(m_RectFieldValue); m_BoundsFieldValue = EditorGUILayout.BoundsField(m_BoundsFieldValue); m_ToggleRightValue = EditorGUILayout.Toggle(m_ToggleRightValue); m_MaskFieldValue = EditorGUILayout.MaskField(m_MaskFieldValue, m_MaskFieldOptions); m_LayerFieldValue = EditorGUILayout.LayerField(m_LayerFieldValue); m_TagFieldValue = EditorGUILayout.TagField(m_TagFieldValue); EditorGUILayout.MinMaxSlider(ref m_MinMaxSliderMinValue, ref m_MinMaxSliderMaxValue, m_MinMaxSliderMinLimit, m_MinMaxSliderMaxLimit); m_SliderValue = EditorGUILayout.Slider(m_SliderValue, 2, 8); m_SliderIntValue = EditorGUILayout.IntSlider(m_SliderIntValue, 11, 23); } GUILayout.BeginHorizontal(); GUILayout.Button(k_ButtonLeftTitle); GUILayout.Button(k_ButtonRightTitle); GUILayout.EndHorizontal(); GUILayout.Button(k_ButtonTopTitle); GUILayout.Button(k_ButtonBottomTitle); SliderProgressTestSO.Update(); if (m_ShowLabelOnFields) { m_ColorFieldValue = EditorGUILayout.ColorField("ColorField", m_ColorFieldValue); m_LayerFieldValue = EditorGUILayout.LayerField("LayerField", m_LayerFieldValue); m_MultiLineTextAreaValue = EditorGUILayout.TextArea(m_MultiLineTextAreaValue); EditorGUILayout.IntSlider(SliderProgressTestProperty, 0, 100, new GUIContent("IntSlider")); ProgressBar(SliderProgressTestProperty.intValue / 100.0f, "Progress Bar"); m_ColorFieldValue = EditorGUILayout.ColorField("ColorField", m_ColorFieldValue); EditorGUILayout.BeginHorizontal(); m_scrollViewPosition = EditorGUILayout.BeginScrollView(m_scrollViewPosition, false, false, GUILayout.MaxWidth(100), GUILayout.MaxHeight(100)); EditorGUILayout.LabelField("ScrollBars", GUILayout.Height(100), GUILayout.Height(200)); EditorGUILayout.EndScrollView(); m_verticalSliderValue = GUILayout.VerticalSlider(m_verticalSliderValue, 0, 30, GUILayout.Height(100), GUILayout.Width(50)); EditorGUILayout.EndHorizontal(); } else { m_ColorFieldValue = EditorGUILayout.ColorField(m_ColorFieldValue); m_LayerFieldValue = EditorGUILayout.LayerField(m_LayerFieldValue); m_MultiLineTextAreaValue = EditorGUILayout.TextArea(m_MultiLineTextAreaValue); EditorGUILayout.IntSlider(SliderProgressTestProperty, 0, 100); ProgressBar(SliderProgressTestProperty.intValue / 100.0f, "Progress Bar"); m_ColorFieldValue = EditorGUILayout.ColorField(m_ColorFieldValue); EditorGUILayout.BeginHorizontal(); m_scrollViewPosition = EditorGUILayout.BeginScrollView(m_scrollViewPosition, false, false, GUILayout.MaxWidth(100), GUILayout.MaxHeight(100)); EditorGUILayout.LabelField("ScrollBars", GUILayout.Height(100), GUILayout.Height(200)); EditorGUILayout.EndScrollView(); m_verticalSliderValue = GUILayout.VerticalSlider(m_verticalSliderValue, 0, 30, GUILayout.Height(100), GUILayout.Width(50)); EditorGUILayout.EndHorizontal(); } SliderProgressTestSO.ApplyModifiedProperties(); }
object ShowInternalItem(string key, System.Type type, object value, Descriptor[] descriptors) { object ret = null; bool endHorizontal = IsShowKey(type); key = GetPrefixKey(key); if (endHorizontal) { EditorGUILayout.BeginHorizontal(); EditorGUILayout.PrefixLabel(key); } if (type == typeof(float)) { if (descriptors != null && descriptors[0] is MinMaxDescriptor) { var minMaxDescriptor = descriptors[0] as MinMaxDescriptor; ret = EditorGUILayout.Slider((float)value, minMaxDescriptor.min, minMaxDescriptor.max); } else { ret = EditorGUILayout.FloatField((float)value); } } else if (type == typeof(string)) { ret = EditorGUILayout.TextField(value as string); } else if (type == typeof(bool)) { ret = EditorGUILayout.Toggle((bool)value); } else if (type == typeof(System.Int32)) { ret = EditorGUILayout.IntField(System.Convert.ToInt32(value)); } else if (type == typeof(System.Int64)) { ret = EditorGUILayout.LongField(System.Convert.ToInt64(value)); } else if (type == typeof(System.Double)) { ret = EditorGUILayout.DoubleField(System.Convert.ToDouble(value)); } else if (type == typeof(System.Single)) { ret = EditorGUILayout.FloatField(System.Convert.ToSingle(value)); } else if (type == typeof(Vector2)) { ret = EditorGUILayout.Vector2Field(key, (Vector2)value); } else if (type == typeof(Vector3)) { ret = EditorGUILayout.Vector3Field(key, (Vector3)value); } else if (type == typeof(Vector4)) { ret = EditorGUILayout.Vector4Field(key, (Vector4)value); } else if (type == typeof(Color)) { ret = EditorGUILayout.ColorField(key, (Color)value); } else if (type == typeof(Rect)) { ret = EditorGUILayout.RectField(key, (Rect)value); } else if (type == typeof(Bounds)) { ret = EditorGUILayout.BoundsField(key, (Bounds)value); } else if (type == typeof(UnityEngine.Object) || type.IsSubclassOf(typeof(UnityEngine.Object))) { ret = EditorGUILayout.ObjectField(key, value as UnityEngine.Object, type, true); } else if (type.IsSubclassOf(typeof(System.Enum))) { ret = EditorGUILayout.EnumPopup(value as System.Enum); } if (endHorizontal) { EditorGUILayout.EndHorizontal(); } return(ret); }
public static object GenericField(string name, object value, Type t, MemberInfo member = null, object context = null) { if (t == null) { GUILayout.Label("NO TYPE PROVIDED!"); return(value); } if (typeof(Delegate).IsAssignableFrom(t)) { return(value); } name = name.SplitCamelCase(); IEnumerable <Attribute> attributes = new Attribute[0]; if (member != null) { if (t.GetCustomAttributes(typeof(HideInInspector), true).FirstOrDefault() != null) { return(value); } attributes = member.GetCustomAttributes(true).Cast <Attribute>(); if (attributes.Any(a => a is HideInInspector)) { return(value); } } if (member != null) { var nameAtt = attributes.FirstOrDefault(a => a is NameAttribute) as NameAttribute; if (nameAtt != null) { name = nameAtt.name; } } if (typeof(UnityEngine.Object).IsAssignableFrom(t)) { return(EditorGUILayout.ObjectField(name, (UnityEngine.Object)value, t, typeof(Component).IsAssignableFrom(t) || t == typeof(GameObject))); } if ((value != null && value.GetType().IsAbstract) || (value == null && t.IsAbstract)) { EditorGUILayout.LabelField(name, string.Format("Abstract ({0})", t.FriendlyName())); return(value); } if (value == null && !t.IsAbstract && !t.IsInterface && (t.IsValueType || t.GetConstructor(Type.EmptyTypes) != null || t.IsArray)) { if (t.IsArray) { value = Array.CreateInstance(t.GetElementType(), 0); } else { value = Activator.CreateInstance(t); } } if (t == typeof(bool)) { return(EditorGUILayout.Toggle(name, (bool)value)); } if (t == typeof(int)) { return(EditorGUILayout.IntField(name, (int)value)); } if (t == typeof(float)) { return(EditorGUILayout.FloatField(name, (float)value)); } if (t == typeof(byte)) { return(Convert.ToByte(Mathf.Clamp(EditorGUILayout.IntField(name, (byte)value), 0, 255))); } if (t == typeof(Vector2)) { return(EditorGUILayout.Vector2Field(name, (Vector2)value)); } if (t == typeof(Vector3)) { return(EditorGUILayout.Vector3Field(name, (Vector3)value)); } if (t == typeof(Vector4)) { return(EditorGUILayout.Vector4Field(name, (Vector4)value)); } if (t == typeof(Quaternion)) { var quat = (Quaternion)value; var vec4 = new Vector4(quat.x, quat.y, quat.z, quat.w); vec4 = EditorGUILayout.Vector4Field(name, vec4); return(new Quaternion(vec4.x, vec4.y, vec4.z, vec4.w)); } if (t == typeof(Color)) { return(EditorGUILayout.ColorField(name, (Color)value)); } if (t == typeof(Rect)) { return(EditorGUILayout.RectField(name, (Rect)value)); } if (t == typeof(AnimationCurve)) { return(EditorGUILayout.CurveField(name, (AnimationCurve)value)); } if (t == typeof(Bounds)) { return(EditorGUILayout.BoundsField(name, (Bounds)value)); } if (t == typeof(string)) { return(EditorGUILayout.TextField(name, (string)value)); } if (t == typeof(LayerMask)) { return(LayerMaskField(name, (LayerMask)value)); } if (typeof(IList).IsAssignableFrom(t)) { return(ListEditor(name, (IList)value, t, context)); } if (typeof(IDictionary).IsAssignableFrom(t)) { //目前json序列化只支持以string为key的类型 var keyType = t.GetGenericArguments()[0]; if (keyType == typeof(string)) { return(DictionaryEditor(name, (IDictionary)value, t, context)); } } if (t.IsSubclassOf(typeof(System.Enum))) { #if UNITY_5 if (t.GetCustomAttributes(typeof(FlagsAttribute), true).FirstOrDefault() != null) { return(EditorGUILayout.EnumMaskPopup(new GUIContent(name), (System.Enum)value)); } #endif return(EditorGUILayout.EnumPopup(name, (System.Enum)value)); } //show nested class members recursively if (value != null && !t.IsEnum && !t.IsInterface) { GUILayout.BeginVertical(); EditorGUILayout.LabelField(name, t.FriendlyName()); EditorGUI.indentLevel++; ShowAutoEditorGUI(value); EditorGUI.indentLevel--; GUILayout.EndVertical(); } else { EditorGUILayout.LabelField(name, string.Format("({0})", t.FriendlyName())); } return(value); }
public static void DrawDungeonGenerator(DungeonGenerator generator, bool isRuntimeDungeon) { generator.DungeonFlow = (DungeonFlow)EditorGUILayout.ObjectField("Dungeon Flow", generator.DungeonFlow, typeof(DungeonFlow), false); generator.ShouldRandomizeSeed = EditorGUILayout.Toggle(new GUIContent("Randomize Seed", "If checked, a new random seed will be created every time a dungeon is generated. If unchecked, a specific seed will be used each time"), generator.ShouldRandomizeSeed); if (!generator.ShouldRandomizeSeed) { generator.Seed = EditorGUILayout.IntField(new GUIContent("Seed", "The seed used to generate a dungeon layout. Generating a dungoen multiple times with the same seed will produce the exact same results each time"), generator.Seed); } generator.MaxAttemptCount = EditorGUILayout.IntField(new GUIContent("Max Failed Attempts", "The maximum number of times DunGen is allowed to fail at generating a dungeon layout before giving up. This only applies in-editor; in a packaged build, DunGen will keep trying indefinitely"), generator.MaxAttemptCount); generator.LengthMultiplier = EditorGUILayout.FloatField(new GUIContent("Length Multiplier", "Used to alter the length of the dungeon without modifying the Dungeon Flow asset. 1 = normal-length, 2 = double-length, 0.5 = half-length, etc."), generator.LengthMultiplier); generator.IgnoreSpriteBounds = EditorGUILayout.Toggle(new GUIContent("Ignore Sprite Bounds", "When calculating bounding boxes for tiles, if this is checked, sprited will be ignored"), generator.IgnoreSpriteBounds); generator.UpVector = EditorGUILayout.Vector3Field(new GUIContent("Up Vector", "The up direction of the dungeon. This won't actually rotate your dungeon, but it must match the expected up-vector for your dungeon layout - usually (0, 1, 0) for 3D and (0, 0, -1) for 2D"), generator.UpVector); if (generator.LengthMultiplier < 0) { generator.LengthMultiplier = 0.0f; } if (isRuntimeDungeon) { generator.DebugRender = EditorGUILayout.Toggle("Debug Render", generator.DebugRender); } generator.PlaceTileTriggers = EditorGUILayout.Toggle(new GUIContent("Place Tile Triggers", "Places trigger colliders around Tiles which can be used in conjunction with the DungenCharacter component to receieve events when changing rooms"), generator.PlaceTileTriggers); generator.TileTriggerLayer = EditorGUILayout.LayerField(new GUIContent("Trigger Layer", "The layer to place the tile root objects on if \"Place Tile Triggers\" is checked"), generator.TileTriggerLayer); if (isRuntimeDungeon) { generator.GenerateAsynchronously = EditorGUILayout.Toggle(new GUIContent("Generate Asynchronously", "If checked, DunGen will generate the layout without blocking Unity's main thread, allowing for things like animated loading screens to be shown"), generator.GenerateAsynchronously); EditorGUI.BeginDisabledGroup(!generator.GenerateAsynchronously); generator.MaxAsyncFrameMilliseconds = EditorGUILayout.Slider(new GUIContent("Max Frame Time", "How many milliseconds the dungeon generation is allowed to take per-frame"), generator.MaxAsyncFrameMilliseconds, 0f, 1000f); generator.PauseBetweenRooms = EditorGUILayout.Slider(new GUIContent("Pause Between Rooms", "If greater than zero, the dungeon generation will pause for the set time (in seconds) after placing a room; useful for visualising the generation process"), generator.PauseBetweenRooms, 0, 5); EditorGUI.EndDisabledGroup(); } EditorGUI.BeginChangeCheck(); generator.RestrictDungeonToBounds = EditorGUILayout.Toggle(new GUIContent("Restrict to Bounds?", "If checked, tiles will only be placed within the specified bounds below. May increase generation times"), generator.RestrictDungeonToBounds); EditorGUI.BeginDisabledGroup(!generator.RestrictDungeonToBounds); generator.TilePlacementBounds = EditorGUILayout.BoundsField(new GUIContent("Placement Bounds", "Tiles are not allowed to be placed outside of these bounds"), generator.TilePlacementBounds); EditorGUI.EndDisabledGroup(); if (EditorGUI.EndChangeCheck() && isRuntimeDungeon) { SceneView.RepaintAll(); } EditorGUILayout.Space(); EditorGUILayout.Space(); EditorGUILayout.BeginVertical("box"); EditorGUILayout.LabelField("Global Overrides", EditorStyles.boldLabel); EditorGUILayout.Space(); EditorGUILayout.BeginHorizontal(); generator.OverrideRepeatMode = EditorGUILayout.Toggle(generator.OverrideRepeatMode, GUILayout.Width(10)); bool previousEnabled = GUI.enabled; GUI.enabled = generator.OverrideRepeatMode; generator.RepeatMode = (TileRepeatMode)EditorGUILayout.EnumPopup("Repeat Mode", generator.RepeatMode); GUI.enabled = previousEnabled; EditorGUILayout.EndHorizontal(); DrawOverride("Allow Tile Rotation", ref generator.OverrideAllowTileRotation, ref generator.AllowTileRotation); EditorGUILayout.EndVertical(); }
// Update is called once per frame protected override void OnTCInspectorGUI() { var doSim = GetProperty("_manager.m_noSimulation"); bool sim = doSim.hasMultipleDifferentValues || !doSim.boolValue; if (m_tabGroup.ToggleArea("Particle Manager", new Color(1.0f, 0.8f, 0.8f))) { GUI.enabled = !EditorApplication.isPlaying; GUILayout.Space(5.0f); GUILayout.BeginHorizontal(); ToolbarToggle("_manager.looping", new GUIContent("Loop", "Looping vs One shot")); ToolbarToggle("_manager.playOnAwake", new GUIContent("Play on awake", "Play when instantiated or play on script event")); ToolbarToggle("_manager.prewarm", new GUIContent("Prewarm", "Simulate particles on first frame to prevent startup issues")); ToolbarToggle("_manager.m_noSimulation", new GUIContent("No Simulation", "Simulation on/off. Useful when driving particles from custom shader to save performance")); GUILayout.Space(10.0f); GUI.enabled = sim; if (GUILayout.Button(new GUIContent("Visualize", "Open visualize window"), EditorStyles.toolbarButton)) { TCParticlesVisualizeWindow.ShowWindow(); } GUI.enabled = true; GUILayout.EndHorizontal(); GUILayout.Space(5.0f); PropField("_manager._duration", new GUIContent("Manager Life", "Seconds that the system is playing / loops")); PropField("_manager.delay", new GUIContent("Start Delay", "Seconds before the system starts playing")); GUI.enabled = true; PropField("_manager._maxParticles", new GUIContent("Max particles", "Maximum amount of particles the system has at any point in time. Keep low to increase performance")); Space(); PropField("_manager._simulationSpace", new GUIContent("Simulation Space", "The space the particles are simulated in. Local will move particles with the system, global will make them independent")); if (sim) { PropField("_emitter._inheritVelocity", new GUIContent("Inherit Velocity", "Factor of movement from the system to be inherited for the particles")); } } m_tabGroup.ToggleAreaEnd("Particle Manager"); if (m_tabGroup.ToggleArea("Emission", new Color(0.8f, 1.0f, 0.8f))) { PropField("_emitter.emit", new GUIContent("Do Emit", "Determines whether the system should be emitting particles right now")); GUILayout.BeginHorizontal(); PropField("_emitter._emissionRate", new GUIContent("Emission Rate", "Amount of particles to emit per second or unit")); PropField("_emitter.m_emissionType", new GUIContent("", "Determines whether particles are emitter per second or per unit"), GUILayout.Width(80.0f)); GUILayout.EndHorizontal(); foreach (TCParticleSystem t in targets) { t.Emitter.EmissionRate = Mathf.Clamp(t.Emitter.EmissionRate, 0, 5000000); } SerializedProperty bursts = GetProperty("_emitter.bursts"); if (!bursts.hasMultipleDifferentValues) { EditorGUILayout.BeginHorizontal(); GUILayout.Label("Bursts", GUILayout.Width(80.0f)); const float width = 51.0f; GUILayout.Label("Time", GUILayout.Width(width)); GUILayout.Label("Particles", GUILayout.Width(width)); EditorGUILayout.EndHorizontal(); int del = -1; for (int i = 0; i < bursts.arraySize; ++i) { GUILayout.BeginHorizontal(); GUILayout.Space(85.0f); EditorGUILayout.PropertyField(CheckBurstProp("time", i), new GUIContent(""), GUILayout.Width(width)); EditorGUILayout.PropertyField(CheckBurstProp("amount", i), new GUIContent(""), GUILayout.Width(width)); GUILayout.Space(10.0f); if (GUILayout.Button("", "OL Minus", GUILayout.Width(24.0f))) { del = i; } GUILayout.EndHorizontal(); } GUILayout.BeginHorizontal(); GUILayout.Space(103.0f + 2 * width); if (GUILayout.Button("", "OL Plus", GUILayout.Width(24.0f))) { bursts.InsertArrayElementAtIndex(bursts.arraySize); } GUILayout.EndHorizontal(); if (del != -1) { bursts.DeleteArrayElementAtIndex(del); } Space(); } PropField("_emitter.pes", new GUIContent("", "Emitter Shape")); GUILayout.Label("Shape emission", EditorStyles.boldLabel); PropField("_emitter.m_emitTag", new GUIContent("Emit Tag", "The tag to link with shape emitters")); } m_tabGroup.ToggleAreaEnd("Emission"); if (m_tabGroup.ToggleArea("Particles", new Color(0.0f, 0.8f, 1.0f))) { if (sim) { PropField("_emitter._energy", new GUIContent("Lifetime", "Amount of seconds particles can be alive")); GUILayout.Space(10.0f); PropField("_emitter._speed", new GUIContent("Start Speed", "Speed particles start with when emitted")); PropField("_emitter._velocityOverLifetime", new GUIContent("Velocity over lifetime", "Velocity and direction over lifetime. Lifetime is [0...1]")); Space(); } PropField("_emitter._size", new GUIContent("Start Size", "Size in units that particles start with")); if (sim) { PropField("_emitter._sizeOverLifetime", new GUIContent("Size Over Lifetime", "A factor [0..1] to multiply the base size with over the lifetime of the particle [0..1]")); } Space(); PropField("_emitter._rotation", new GUIContent("Start Rotation", "The rotation a particle starts with")); if (sim) { PropField("_emitter._angularVelocity", new GUIContent("Angular Velocity", "Degrees per second all particles rotate with")); } if (sim) { GUILayout.Space(10.0f); GUILayout.BeginHorizontal(); var mode = GetProperty("_particleRenderer.colourGradientMode"); var colProp = GetProperty("_particleRenderer._colourOverLifetime"); switch (mode.enumValueIndex) { case (int)ParticleColourGradientMode.OverLifetime: EditorGUILayout.PropertyField(colProp, new GUIContent("Color over lifetime")); break; default: EditorGUILayout.PropertyField(colProp, new GUIContent("Color over speed")); break; } EnumPopup(mode, (ParticleColourGradientMode)mode.enumValueIndex); GUILayout.EndHorizontal(); if (mode.enumValueIndex != (int)ParticleColourGradientMode.OverLifetime) { EditorGUILayout.PropertyField(GetProperty("_particleRenderer.maxSpeed"), new GUIContent("Max Speed", "The speed where particles are colored like the end of the gradient")); } } } m_tabGroup.ToggleAreaEnd("Particles"); if (sim) { if (m_tabGroup.ToggleArea("Forces", new Color(1.0f, 1.0f, 0.8f))) { PropField("_forcesManager._maxForces", new GUIContent("Max Forces", "The maximum number of forces that can affect this system, determined by priority")); var maxProp = GetProperty("_forcesManager._maxForces"); if (!maxProp.hasMultipleDifferentValues && maxProp.intValue != 0) { PropField("_manager.gravityMultiplier", new GUIContent("Gravity Multiplier", "The amount of gravity (determined in physics settings) applied to the particles")); PropField("_emitter._constantForce", new GUIContent("Constant Force", "A force that is constantly applied to the particles, accelerating them in one direction")); } EditorGUILayout.BeginHorizontal(); PropField("_forcesManager._forceLayers", new GUIContent("Force Layers", "Layers to filter what forces can affect this system")); if (Targets.Length == 1) { if (GUILayout.Button("", "OL Plus", GUILayout.Width(20.0f))) { Targets[0].ForceManager.BaseForces.Add(null); } } EditorGUILayout.EndHorizontal(); if (Targets.Length == 1) { var forceManager = Targets[0].ForceManager; int del = -1; for (int i = 0; i < forceManager.BaseForces.Count; ++i) { GUILayout.BeginHorizontal(); GUILayout.Space(20.0f); forceManager.BaseForces[i] = EditorGUILayout.ObjectField("Link to ", forceManager.BaseForces[i], typeof(TCForce), true) as TCForce; if (GUILayout.Button("", "OL Minus", GUILayout.Width(20.0f))) { del = i; } GUILayout.EndHorizontal(); } if (del != -1) { forceManager.BaseForces.RemoveAt(del); } forceManager.MaxForces = Mathf.Max(forceManager.MaxForces, forceManager.BaseForces.Count); } GUILayout.BeginHorizontal(); SerializedProperty curveProp = GetProperty("_manager.dampingIsCurve"); EditorGUILayout.PropertyField( curveProp.boolValue ? GetProperty("_manager.dampingCurve") : GetProperty("_manager.damping"), new GUIContent("Damping")); curveProp.boolValue = (DampingPopup) EditorGUILayout.EnumPopup("", curveProp.boolValue ? DampingPopup.Curve : DampingPopup.Constant, EditorStyles.toolbarPopup, GUILayout.Width(15.0f)) == DampingPopup.Curve; GUILayout.EndHorizontal(); PropField("_manager.MaxSpeed", new GUIContent("Max Speed", "The speed particles are clamped to. -1 for infinity")); PropField("_forcesManager.useBoidsFlocking", new GUIContent("Boids Flocking", "Determines whether the particles should flock. Flocking gives a firefly like behavior to the particles")); if (GetProperty("_forcesManager.useBoidsFlocking").boolValue) { PropField("_forcesManager.boidsPositionStrength", new GUIContent("Position Strength", "The strength at which particles are pushed to the average position of all particles")); PropField("_forcesManager.boidsVelocityStrength", new GUIContent("Velocity Strength", "The strength at which particles are forced to the average velocity of all particles")); PropField("_forcesManager.boidsCenterStrength", new GUIContent("Center Position Strength", "The strength at which particles are pushed to the position of the particle system")); } } m_tabGroup.ToggleAreaEnd("Forces"); if (m_tabGroup.ToggleArea("Collision", new Color(1.0f, 0.8f, 1.0f))) { PropField("_colliderManager._maxColliders", new GUIContent("Max Colliders", "The maximum number of colliders that can affect this system, determined by priority")); var maxProp = GetProperty("_colliderManager._maxColliders"); if (!maxProp.hasMultipleDifferentValues && maxProp.intValue != 0) { PropField("_colliderManager.overrideBounciness", new GUIContent("Override Bounciness")); if (GetProperty("_colliderManager.overrideBounciness").boolValue) { PropField("_colliderManager._bounciness", new GUIContent("Bounciness", "Amount that particles bounce back after an collision")); } PropField("_colliderManager.overrideStickiness", new GUIContent("Override stickiness")); if (GetProperty("_colliderManager.overrideStickiness").boolValue) { PropField("_colliderManager._stickiness", new GUIContent("Bounciness", "Amount that particles stick after an collision")); } PropField("_colliderManager._particleThickness", new GUIContent("Particle Thickness")); } EditorGUILayout.BeginHorizontal(); PropField("_colliderManager._colliderLayers", new GUIContent("Collider Layers", "Layers to filter which colliders can affect this system")); if (Targets.Length == 1) { if (GUILayout.Button("", "OL Plus", GUILayout.Width(20.0f))) { Targets[0].ColliderManager.BaseColliders.Add(null); } } EditorGUILayout.EndHorizontal(); if (Targets.Length == 1) { var baseColliders = Targets[0].ColliderManager.BaseColliders; int del = -1; for (int i = 0; i < baseColliders.Count; ++i) { GUILayout.BeginHorizontal(); GUILayout.Space(20.0f); baseColliders[i] = EditorGUILayout.ObjectField("Link to ", baseColliders[i], typeof(TCCollider), true) as TCCollider; if (GUILayout.Button("", "OL Minus", GUILayout.Width(20.0f))) { del = i; } GUILayout.EndHorizontal(); } if (del != -1) { baseColliders.RemoveAt(del); } } foreach (var system in Targets) { system.ColliderManager.MaxColliders = Mathf.Max(system.ColliderManager.MaxColliders, system.ColliderManager.BaseColliders.Count); } } m_tabGroup.ToggleAreaEnd("Collision"); } if (m_tabGroup.ToggleArea("Renderer", new Color(0.8f, 1.0f, 1.0f))) { PropField("_particleRenderer._material", new GUIContent("Material")); PropField("_particleRenderer._renderMode", new GUIContent("Render Mode")); var shapeProp = GetProperty("_emitter.pes.shape"); if (!shapeProp.hasMultipleDifferentValues && (EmitShapes)shapeProp.enumValueIndex == EmitShapes.PointCloud) { PropField("_particleRenderer.pointCloudNormals", new GUIContent("Point Cloud Normals")); } var renderMode = (GeometryRenderMode)GetProperty("_particleRenderer._renderMode").enumValueIndex; switch (renderMode) { case GeometryRenderMode.Mesh: PropField("_particleRenderer._mesh", new GUIContent("Mesh", "The mesh that is used for the particles to render with. Keep as low poly as possible")); break; case GeometryRenderMode.TailStretchBillboard: case GeometryRenderMode.StretchedBillboard: PropField("_particleRenderer._lengthScale", new GUIContent("Length Scale", "Factor that determines the length when particles has no velocity")); PropField("_particleRenderer._speedScale", new GUIContent("Speed Scale", "Factor that determines how much a particle should stretch when it has velocity")); if (renderMode == GeometryRenderMode.TailStretchBillboard) { PropField("_particleRenderer.TailUv", new GUIContent("Tail UV", "The UV Coordinate of the vertex where the particles begins to stretch")); } break; } if (renderMode == GeometryRenderMode.Billboard || renderMode == GeometryRenderMode.StretchedBillboard || renderMode == GeometryRenderMode.TailStretchBillboard) { PropField("_particleRenderer.isPixelSize", new GUIContent("Is Pixel Size", "Determines whether the particle size is in units or screen pixels")); if (sim) { PropField("_particleRenderer.spriteSheetAnimation", new GUIContent("Sprite Sheet", "Enables sprite sheet animation")); } } if (sim) { if (GetProperty("_particleRenderer.spriteSheetAnimation").boolValue) { PropField("_particleRenderer.spriteSheetColumns", new GUIContent("Sheet Columns", "Nr. of columns in the sprite sheet")); PropField("_particleRenderer.spriteSheetRows", new GUIContent("Sheet rows", "Nr. of rows in the sprite sheet")); PropField("_particleRenderer.spriteSheetCycles", new GUIContent("Sheet cycles", "Amount of cycles a particle should do in it's lifetime")); PropField("_particleRenderer.spriteSheetBasePlaySpeed", new GUIContent("Base Play Speed", "Base speed sprite sheet animation plays at. Useful for particles that life infinitely")); PropField("_particleRenderer.spriteSheetRandomStart", new GUIContent("Random Start", "Should the sprite sheet start playing at a random point in the sprite sheet?")); } } PropField("_particleRenderer.glow", new GUIContent("Glow Strength", "Glow strength of the particles")); PropField("_particleRenderer._useFrustumCulling", new GUIContent("Frustum culling", "Determines whether the system should be frustum culled")); //If supported... PropField("_particleRenderer.CastShadows", new GUIContent("Cast Shadows", "Should this system cast shadows")); PropField("_particleRenderer.ReceiveShadows", new GUIContent("Receive Shadows", "Should particles receive shadows")); if (GetProperty("_particleRenderer._useFrustumCulling").boolValue) { SerializedProperty boundsProp = GetProperty("_particleRenderer._bounds"); boundsProp.boundsValue = EditorGUILayout.BoundsField(boundsProp.boundsValue); PropField("_particleRenderer.culledSimulationMode", new GUIContent("Culled Mode", "Determines how particles are treated when they are culled")); if (GetProperty("_particleRenderer.culledSimulationMode").enumValueIndex == (int)CulledSimulationMode.SlowSimulation) { PropField("_particleRenderer.cullSimulationDelta", new GUIContent("Culled Delta", "Sets the frequency the particles are update when they are culled")); } } } m_tabGroup.ToggleAreaEnd("Renderer"); if (sim) { foreach (var o in targets) { var t = (TCParticleSystem)o; t.ParticleRenderer.UpdateColourOverLifetime(); t.Emitter.UpdateSizeOverLifetime(); } } serializedObject.ApplyModifiedProperties(); if (GUI.changed) { EditorUtility.SetDirty(m_tabGroup); } }
static ExposeProperties() { propertyDrawerFuncs [SerializedPropertyType.Integer] = (field) => { return(EditorGUILayout.IntField(field.Name, ( int )field.Value, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.Boolean] = (field) => { return(EditorGUILayout.Toggle(field.Name, ( bool )field.Value, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.Float] = (field) => { return(EditorGUILayout.FloatField(field.Name, ( float )field.Value, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.String] = (field) => { return(EditorGUILayout.TextField(field.Name, ( string )field.Value, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.Color] = (field) => { return(EditorGUILayout.ColorField(field.Name, ( Color )field.Value, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.ObjectReference] = (field) => { return(EditorGUILayout.ObjectField(field.Name, (UnityEngine.Object)field.Value, field.Type, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.LayerMask] = (field) => { // TODO: test it. return(EditorGUILayout.LayerField(field.Name, ( int )field.Value, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.Enum] = (field) => { return(EditorGUILayout.EnumPopup(field.Name, ( Enum )field.Value, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.Vector2] = (field) => { return(EditorGUILayout.Vector2Field(field.Name, ( Vector2 )field.Value, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.Vector3] = (field) => { return(EditorGUILayout.Vector3Field(field.Name, ( Vector3 )field.Value, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.Vector4] = (field) => { return(EditorGUILayout.Vector4Field(field.Name, ( Vector4 )field.Value, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.Rect] = (field) => { return(EditorGUILayout.RectField(field.Name, ( Rect )field.Value, new GUILayoutOption [0])); }; // TODO: how to implement it? //propertyDrawerFuncs [SerializedPropertyType.ArraySize] = ( field ) => { // return EditorGUILayout.arr ( field.Name, ( Rect ) field.Value, new GUILayoutOption [0] ); //}; // TODO: how to implement it? //propertyDrawerFuncs [SerializedPropertyType.Character] = ( field ) => { // return EditorGUILayout.cha ( field.Name, ( Rect ) field.Value, new GUILayoutOption [0] ); //}; propertyDrawerFuncs [SerializedPropertyType.AnimationCurve] = (field) => { return(EditorGUILayout.CurveField(field.Name, ( AnimationCurve )field.Value, new GUILayoutOption [0])); }; propertyDrawerFuncs [SerializedPropertyType.Bounds] = (field) => { return(EditorGUILayout.BoundsField(field.Name, ( Bounds )field.Value, new GUILayoutOption [0])); }; // TODO: how to implement it? //propertyDrawerFuncs [SerializedPropertyType.Gradient] = ( field ) => { // return EditorGUILayout.gra ( field.Name, ( Bounds ) field.Value, new GUILayoutOption [0] ); //}; // TODO: how to implement it? //propertyDrawerFuncs [SerializedPropertyType.Quaternion] = ( field ) => { // return EditorGUILayout.qua ( field.Name, ( Quaternion ) field.Value, new GUILayoutOption [0] ); //}; }
private void DrawNpc() { EditorGUILayout.BeginVertical("Box"); #region NpcId Property GUILayout.Space(5); //获得Npc类中的_npcId属性 SerializedProperty npcId = _spNpc.FindPropertyRelative("_npcId"); EditorGUILayout.PropertyField(npcId, new GUIContent("NpcID")); #endregion #region NameId GUILayout.Space(5); //获得Npc类中的_nameId属性 SerializedProperty nameId = _spNpc.FindPropertyRelative("_nameId"); EditorGUILayout.PropertyField(nameId, new GUIContent("NameID")); #endregion #region Speed GUILayout.Space(5); SerializedProperty speed = _spNpc.FindPropertyRelative("_speed"); EditorGUILayout.PropertyField(speed, new GUIContent("Speed")); #endregion #region Life GUILayout.Space(5); SerializedProperty life = _spNpc.FindPropertyRelative("_life"); EditorGUILayout.PropertyField(life, new GUIContent("Life")); #endregion #region Button GUILayout.Space(5); Rect rc = GUILayoutUtility.GetRect(_debugButton, GUI.skin.button); const float with = 150f; rc.x = rc.x + (rc.width - with) / 2; rc.width = with; if (GUI.Button(rc, _debugButton)) { Debug.Log("npcId :" + npcId.intValue); Debug.Log("nameId :" + nameId.intValue); Debug.Log("speed :" + speed.floatValue); Debug.Log("life :" + life.floatValue); } #endregion GUILayout.Space(10); // target控制动画开始播放 _fadeGroup.target = EditorGUILayout.Foldout(_fadeGroup.target, "BeginFadeGroup", true); // 系统使用tween渐变faded数值 if (EditorGUILayout.BeginFadeGroup(_fadeGroup.faded)) { SerializedProperty npcId2 = _spNpc.FindPropertyRelative("_npcId"); EditorGUILayout.PropertyField(npcId2, new GUIContent("NpcID")); EditorGUILayout.BoundsField("BoundsField", new Bounds()); EditorGUILayout.BoundsIntField("BoundsIntField", new BoundsInt()); } // begin - end 之间元素会进行动画 EditorGUILayout.EndFadeGroup(); // 又一种风格的空格 GUILayout.Space(10); EditorGUILayout.EndVertical(); }
public static object Draw(string propName, object propValue, ref bool foldout) { if (propValue == null) { return(null); } System.Type type = propValue.GetType(); object obj2 = null; if (type == typeof(float)) { return(EditorGUILayout.FloatField(propName, (float)propValue, new GUILayoutOption[0])); } #if UNITY_5_3_OR_NEWER if (type == typeof(double)) { return(EditorGUILayout.DoubleField(propName, (double)propValue, new GUILayoutOption[0])); } #endif if (type == typeof(int)) { return(EditorGUILayout.IntField(propName, (int)propValue, new GUILayoutOption[0])); } if (type == typeof(uint)) { return((uint)EditorGUILayout.IntField(propName, (int)((uint)propValue), new GUILayoutOption[0])); } if (type == typeof(Vector2)) { return(EditorGUILayout.Vector2Field(propName, (Vector2)propValue, new GUILayoutOption[0])); } if (type == typeof(Vector3)) { return(EditorGUILayout.Vector3Field(propName, (Vector3)propValue, new GUILayoutOption[0])); } if (type == typeof(Vector4)) { return(rdtGuiVector4Field.Draw(propName, (Vector4)propValue, ref foldout)); } if (type == typeof(Matrix4x4)) { return(rdtGuiMatrixField.Draw(propName, (Matrix4x4)propValue, ref foldout)); } if (type == typeof(bool)) { return(EditorGUILayout.Toggle(propName, (bool)propValue, new GUILayoutOption[0])); } if (type.IsEnum) { return(EditorGUILayout.EnumPopup(propName, (Enum)propValue, new GUILayoutOption[0])); } if (type == typeof(string)) { return(EditorGUILayout.TextField(propName, (string)propValue, new GUILayoutOption[0])); } if (type == typeof(Color)) { return(EditorGUILayout.ColorField(propName, (Color)propValue, new GUILayoutOption[0])); } if (type == typeof(Color32)) { return((Color32)EditorGUILayout.ColorField(propName, (Color)((Color32)propValue), new GUILayoutOption[0])); } if (type == typeof(Quaternion)) { Quaternion quaternion = (Quaternion)propValue; Vector4 vector = new Vector4(quaternion.x, quaternion.y, quaternion.z, quaternion.w); obj2 = rdtGuiVector4Field.Draw(propName, vector, ref foldout); vector = (Vector4)obj2; quaternion.x = vector.x; quaternion.y = vector.y; quaternion.z = vector.z; quaternion.w = vector.w; return(quaternion); } if (type == typeof(Bounds)) { return(EditorGUILayout.BoundsField(propName, (Bounds)propValue, new GUILayoutOption[0])); } if (type == typeof(Rect)) { return(EditorGUILayout.RectField(propName, (Rect)propValue, new GUILayoutOption[0])); } if (type.IsArray) { Array arr = (Array)propValue; return(rdtGuiArrayField.Draw(propName, arr, ref foldout)); } if (type == typeof(rdtSerializerButton)) { return(new rdtSerializerButton(GUILayout.Button(propName, new GUILayoutOption[0]))); } if (type == typeof(rdtSerializerSlider)) { rdtSerializerSlider slider = (rdtSerializerSlider)propValue; obj2 = EditorGUILayout.Slider(propName, slider.Value, slider.LimitMin, slider.LimitMax, new GUILayoutOption[0]); return(new rdtSerializerSlider((float)obj2, slider.LimitMin, slider.LimitMax)); } rdtDebug.Debug(string.Concat(new object[] { "rdtGuiProperty: Unknown type: ", type.Name, " (name=", propName, ", value=", propValue, ")" }), new object[0]); return(obj2); }
void Set_Inspector() { GUI.backgroundColor = new Color(1.0f, 1.0f, 0.5f, 1.0f); serializedObject.Update(); if (EditorApplication.isPlaying == false) { // Basic settings EditorGUILayout.Space(); EditorGUILayout.Space(); EditorGUILayout.HelpBox("Basic settings", MessageType.None, true); EditorGUILayout.Slider(DistanceProp, 0.1f, 10.0f, "Distance"); EditorGUILayout.Slider(SpacingProp, 0.05f, 1.0f, "Spacing"); EditorGUILayout.Slider(Track_MassProp, 0.1f, 100.0f, "Mass"); // Shape settings EditorGUILayout.Space(); EditorGUILayout.HelpBox("Shape settings", MessageType.None, true); SelectedAngleProp.intValue = EditorGUILayout.IntPopup("Angle of Front Arc", SelectedAngleProp.intValue, AngleNames, AngleValues); Rear_FlagProp.boolValue = EditorGUILayout.Toggle("Set Rear Arc", Rear_FlagProp.boolValue); if (Rear_FlagProp.boolValue) { Angle_RearProp.intValue = EditorGUILayout.IntPopup("Angle of Rear Arc", Angle_RearProp.intValue, AngleNames, AngleValues); } EditorGUILayout.IntSlider(NumberProp, 0, 80, "Number of Straight"); // Collider settings EditorGUILayout.Space(); EditorGUILayout.HelpBox("Collider settings", MessageType.None, true); Collider_InfoProp.boundsValue = EditorGUILayout.BoundsField("Box Collider", Collider_InfoProp.boundsValue); Collider_MaterialProp.objectReferenceValue = EditorGUILayout.ObjectField("Physic Material", Collider_MaterialProp.objectReferenceValue, typeof(PhysicMaterial), false); // Mesh settings EditorGUILayout.Space(); EditorGUILayout.HelpBox("Mesh settings", MessageType.None, true); Track_L_MeshProp.objectReferenceValue = EditorGUILayout.ObjectField("Mesh of Left", Track_L_MeshProp.objectReferenceValue, typeof(Mesh), false); Track_R_MeshProp.objectReferenceValue = EditorGUILayout.ObjectField("Mesh of Right", Track_R_MeshProp.objectReferenceValue, typeof(Mesh), false); Track_L_MaterialProp.objectReferenceValue = EditorGUILayout.ObjectField("Material of Left", Track_L_MaterialProp.objectReferenceValue, typeof(Material), false); Track_R_MaterialProp.objectReferenceValue = EditorGUILayout.ObjectField("Material of Right", Track_R_MaterialProp.objectReferenceValue, typeof(Material), false); // Reinforce settings EditorGUILayout.Space(); EditorGUILayout.HelpBox("Reinforce settings", MessageType.None, true); SubJoint_TypeProp.intValue = EditorGUILayout.Popup("Reinforce Type", SubJoint_TypeProp.intValue, SubJointNames); if (SubJoint_TypeProp.intValue != 2) { EditorGUILayout.Slider(Reinforce_RadiusProp, 0.1f, 10.0f, "Radius of SphereCollider"); } // Interpolation settings EditorGUILayout.Space(); EditorGUILayout.HelpBox("Interpolation settings", MessageType.None, true); Use_InterpolationProp.boolValue = EditorGUILayout.Toggle("Use Interpolation", Use_InterpolationProp.boolValue); if (Use_InterpolationProp.boolValue) { EditorGUILayout.Slider(Joint_OffsetProp, 0.0f, 1.0f, "Joint Offset"); Interpolation_L_MeshProp.objectReferenceValue = EditorGUILayout.ObjectField("Mesh of Left", Interpolation_L_MeshProp.objectReferenceValue, typeof(Mesh), false); Interpolation_R_MeshProp.objectReferenceValue = EditorGUILayout.ObjectField("Mesh of Right", Interpolation_R_MeshProp.objectReferenceValue, typeof(Mesh), false); Interpolation_L_MaterialProp.objectReferenceValue = EditorGUILayout.ObjectField("Material of Left", Interpolation_L_MaterialProp.objectReferenceValue, typeof(Material), false); Interpolation_R_MaterialProp.objectReferenceValue = EditorGUILayout.ObjectField("Material of Right", Interpolation_R_MaterialProp.objectReferenceValue, typeof(Material), false); } // Special settings EditorGUILayout.Space(); EditorGUILayout.HelpBox("Specail settings for Unity5", MessageType.None, true); EditorGUILayout.Slider(Special_OffsetProp, -0.1f, 0.1f, "Offset for Unity5"); // Durability settings EditorGUILayout.Space(); EditorGUILayout.HelpBox("Durability settings", MessageType.None, true); EditorGUILayout.Slider(Track_DurabilityProp, 1.0f, 1000000.0f, "Track Durability"); if (Track_DurabilityProp.floatValue >= 1000000) { Track_DurabilityProp.floatValue = Mathf.Infinity; } EditorGUILayout.Slider(BreakForceProp, 10000.0f, 1000000.0f, "HingeJoint BreakForce"); if (BreakForceProp.floatValue >= 1000000) { BreakForceProp.floatValue = Mathf.Infinity; } // for Static Track EditorGUILayout.Space(); EditorGUILayout.Space(); EditorGUILayout.HelpBox("Edit Static Track", MessageType.None, true); Static_FlagProp.boolValue = EditorGUILayout.Toggle("for Static Track", Static_FlagProp.boolValue); // Update Value EditorGUILayout.Space(); EditorGUILayout.Space(); RealTime_FlagProp.boolValue = EditorGUILayout.Toggle("Real Time Update", RealTime_FlagProp.boolValue); if (GUILayout.Button("Update Value")) { if (RealTime_FlagProp.boolValue == false) { Create(); } } EditorGUILayout.Space(); EditorGUILayout.Space(); } else // in PlayMode. { EditorGUILayout.Space(); EditorGUILayout.Space(); EditorGUILayout.HelpBox("Edit Static Track", MessageType.None, true); if (Static_FlagProp.boolValue) // for making Static_Track { if (!Prefab_FlagProp.boolValue) // Static_Track is not prepared yet. { RealTime_FlagProp.boolValue = false; EditorGUILayout.Space(); EditorGUILayout.Space(); if (GUILayout.Button("Change into Static Track")) { Change_Static_Track(); Prefab_FlagProp.boolValue = true; } EditorGUILayout.Space(); EditorGUILayout.Space(); } else // Static_Track has been prepared. { EditorGUILayout.Space(); EditorGUILayout.Space(); if (GUILayout.Button("Create Prefab in 'Assets' folder")) { Create_Prefab(); } EditorGUILayout.Space(); EditorGUILayout.Space(); } } } // serializedObject.ApplyModifiedProperties(); }
public static object PropertyField(Type type, GUIContent label, object value, params GUILayoutOption[] options) { // generic // object //layermask //array if (type.IsArray) { } if (type.IsEnum) { return(EditorGUILayout.EnumPopup(label, (Enum)value, options)); } if (type == typeof(int)) { return(EditorGUILayout.IntField(label, (int)value, options)); } if (type == typeof(bool)) { return(EditorGUILayout.Toggle(label, (bool)value, options)); } if (type == typeof(string)) { return(EditorGUILayout.TextField(label, (string)value, options)); } if (type == typeof(float)) { return(EditorGUILayout.FloatField(label, (float)value, options)); } if (type == typeof(char)) { return(EditorGUILayout.IntField(label, (int)value, options)); } if (type == typeof(Color)) { return(EditorGUILayout.ColorField(label, (Color)value, options)); } if (type == typeof(Vector2)) { return(EditorGUILayout.Vector2Field(label, (Vector2)value, options)); } if (type == typeof(Vector3)) { return(EditorGUILayout.Vector3Field(label, (Vector3)value, options)); } if (type == typeof(Vector4)) { return(EditorGUILayout.Vector4Field(label, (Vector4)value, options)); } if (type == typeof(Vector2Int)) { return(EditorGUILayout.Vector2IntField(label, (Vector2Int)value, options)); } if (type == typeof(Vector3Int)) { return(EditorGUILayout.Vector3IntField(label, (Vector3Int)value, options)); } if (type == typeof(Rect)) { return(EditorGUILayout.RectField(label, (Rect)value, options)); } if (type == typeof(RectInt)) { return(EditorGUILayout.RectIntField(label, (RectInt)value, options)); } if (type == typeof(Bounds)) { return(EditorGUILayout.BoundsField(label, (Bounds)value, options)); } if (type == typeof(BoundsInt)) { return(EditorGUILayout.BoundsIntField(label, (BoundsInt)value, options)); } if (type == typeof(AnimationCurve)) { return(EditorGUILayout.CurveField(label, (AnimationCurve)value, options)); } if (type == typeof(Gradient)) { return(EditorGUILayout.GradientField(label, (Gradient)value, options)); } if (type == typeof(Quaternion)) { return(QuaternionField(label, (Quaternion)value, options)); } return(null); }