public static void ShowField(BGCurvePointI point, BGCurvePointField field, Action <string, AnimationCurve> animationCurveCallback = null)
        {
            var name = point.Curve.IndexOf(field) + ") " + field.FieldName;

            switch (field.Type)
            {
            case BGCurvePointField.TypeEnum.Bool:
                BGEditorUtility.BoolField(name, point.GetField <bool>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Int:
                BGEditorUtility.IntField(name, point.GetField <int>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Float:
                BGEditorUtility.FloatField(name, point.GetField <float>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Vector3:
                BGEditorUtility.Vector3Field(name, null, point.GetField <Vector3>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Bounds:
                BGEditorUtility.BoundsField(name, point.GetField <Bounds>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Color:
                BGEditorUtility.ColorField(name, point.GetField <Color>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.String:
                BGEditorUtility.TextField(name, point.GetField <string>(field.FieldName), v => point.SetField(field.FieldName, v), false);
                break;

            case BGCurvePointField.TypeEnum.AnimationCurve:
                BGEditorUtility.Horizontal(() =>
                {
                    BGEditorUtility.AnimationCurveField(name, point.GetField <AnimationCurve>(field.FieldName), v => point.SetField(field.FieldName, v));

                    if (animationCurveCallback != null && GUILayout.Button("Set", GUILayout.Width(40)))
                    {
                        animationCurveCallback(field.FieldName, point.GetField <AnimationCurve>(field.FieldName));
                    }
                });

                break;

            case BGCurvePointField.TypeEnum.Quaternion:
                BGEditorUtility.QuaternionField(name, point.GetField <Quaternion>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.GameObject:
                BGEditorUtility.GameObjectField(name, point.GetField <GameObject>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.Component:
                BGEditorUtility.ComponentChoosableField(name, point.GetField <Component>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.BGCurve:
                BGEditorUtility.BGCurveField(name, point.GetField <BGCurve>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;

            case BGCurvePointField.TypeEnum.BGCurvePointComponent:
                BGEditorUtility.Horizontal(() =>
                {
                    BGEditorUtility.BGCurvePointComponentField(name, point.GetField <BGCurvePointComponent>(field.FieldName), v => point.SetField(field.FieldName, v));
                    var currentPoint = point.GetField <BGCurvePointComponent>(field.FieldName);

                    if (currentPoint == null || currentPoint.Curve.PointsCount < 2)
                    {
                        return;
                    }

                    var indexOfField = currentPoint.Curve.IndexOf(currentPoint);

                    if (GUILayout.Button("" + indexOfField, GUILayout.Width(40)))
                    {
                        BGCurveChosePointWindow.Open(indexOfField, currentPoint.Curve, c => point.SetField(field.FieldName, c));
                    }
                });
                break;

            case BGCurvePointField.TypeEnum.BGCurvePointGO:
                BGEditorUtility.BGCurvePointGOField(name, point.GetField <BGCurvePointGO>(field.FieldName), v => point.SetField(field.FieldName, v));
                break;
            }
        }
        private static void ShowSettings()
        {
            BGEditorUtility.SwapLabelWidth(300, () =>
            {
                BGEditorUtility.Vertical(new GUIStyle("Box")
                {
                    padding = new RectOffset(Padding, Padding, Padding, Padding)
                }, () =>
                {
                    EditorGUILayout.LabelField(settings.Name, new GUIStyle("Box")
                    {
                        fontSize = 22
                    });

                    if (GUILayout.Button(new GUIContent("Reset to defaults", "Reset all editor settings to their defaults.")) &&
                        BGEditorUtility.Confirm("Reset settings", "Reset All Editor settings to defaults? It does not affect local settings.", "Reset"))
                    {
                        settings.Reset();
                    }

                    var keys = settings.Keys;
                    foreach (var key in keys)
                    {
                        var descriptor = settings.GetSetting(key);
                        if (descriptor.Name == null)
                        {
                            continue;
                        }

                        Action ui;
                        if (descriptor is BGAbstractSettingsForEditor.SettingEnum)
                        {
                            var setting = (BGAbstractSettingsForEditor.SettingEnum)descriptor;
                            ui          = () =>
                            {
                                setting.Value = setting.Ui(setting.Value);
                            };
                        }
                        else if (descriptor is BGAbstractSettingsForEditor.SettingBool)
                        {
                            var setting = (BGAbstractSettingsForEditor.SettingBool)descriptor;
                            ui          = () => { BGEditorUtility.ToggleField(setting.Value, descriptor.Name, b => setting.Value = b); };
                        }
                        else if (descriptor is BGAbstractSettingsForEditor.SettingInt)
                        {
                            var setting = (BGAbstractSettingsForEditor.SettingInt)descriptor;
                            ui          = () => { BGEditorUtility.IntField(descriptor.Name, setting.Value, b => setting.Value = b); };
                        }
                        else if (descriptor is BGAbstractSettingsForEditor.SettingString)
                        {
                            var setting = (BGAbstractSettingsForEditor.SettingString)descriptor;
                            ui          = () => { BGEditorUtility.TextField(descriptor.Name, setting.Value, b => setting.Value = b, false); };
                        }
                        else if (descriptor is BGAbstractSettingsForEditor.SettingFloat)
                        {
                            var setting = (BGAbstractSettingsForEditor.SettingFloat)descriptor;
                            ui          = () => { BGEditorUtility.FloatField(descriptor.Name, setting.Value, b => setting.Value = b); };
                        }
                        else if (descriptor is BGAbstractSettingsForEditor.SettingColor)
                        {
                            var setting = (BGAbstractSettingsForEditor.SettingColor)descriptor;
                            ui          = () => { BGEditorUtility.ColorField(descriptor.Name, setting.Value, b => setting.Value = b); };
                        }
                        else
                        {
                            throw new UnityException("Unsupported type");
                        }

                        BGEditorUtility.VerticalBox(() =>
                        {
                            ui();
                            EditorGUILayout.HelpBox(descriptor.Description, MessageType.Info);
                        });
                    }
                });
            });
        }