Axis.cs

/******************************************/
/*                                        */
/*     Copyright (c) 2021 monitor1394     */
/*     https://github.com/monitor1394     */
/*                                        */
/******************************************/
 
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
 
namespace XCharts
{
    [System.Serializable]
    public class Axis : MainComponent
    {
        public enum AxisType
        {
            Value,
            Category,
            Log,
            Time
        }
 
        public enum AxisMinMaxType
        {
            Default,
            MinMax,
            Custom
        }
        public enum AxisPosition
        {
            Left,
            Right,
            Bottom,
            Top
        }
 
        [SerializeField] protected bool m_Show = true;
        [SerializeField] protected AxisType m_Type;
        [SerializeField] protected AxisMinMaxType m_MinMaxType;
        [SerializeField] protected int m_GridIndex;
        [SerializeField] protected int m_PolarIndex;
        [SerializeField] protected AxisPosition m_Position;
        [SerializeField] protected float m_Offset;
        [SerializeField] protected float m_Min;
        [SerializeField] protected float m_Max;
        [SerializeField] protected int m_SplitNumber = 5;
        [SerializeField] protected float m_Interval = 0;
        [SerializeField] protected bool m_BoundaryGap = true;
        [SerializeField] protected int m_MaxCache = 0;
        [SerializeField] protected float m_LogBase = 10;
        [SerializeField] protected bool m_LogBaseE = false;
        [SerializeField] protected int m_CeilRate = 0;
        [SerializeField] protected bool m_Inverse = false;
        [SerializeField] private bool m_Clockwise = true;
        [SerializeField] private bool m_InsertDataToHead;
        [SerializeField] private IconStyle m_IconStyle = new IconStyle();
        [SerializeField] protected List<Sprite> m_Icons = new List<Sprite>();
        [SerializeField] protected List<string> m_Data = new List<string>();
        [SerializeField] protected AxisLine m_AxisLine = AxisLine.defaultAxisLine;
        [SerializeField] protected AxisName m_AxisName = AxisName.defaultAxisName;
        [SerializeField] protected AxisTick m_AxisTick = AxisTick.defaultTick;
        [SerializeField] protected AxisLabel m_AxisLabel = AxisLabel.defaultAxisLabel;
        [SerializeField] protected AxisSplitLine m_SplitLine = AxisSplitLine.defaultSplitLine;
        [SerializeField] protected AxisSplitArea m_SplitArea = AxisSplitArea.defaultSplitArea;
 
        [NonSerialized] private double m_MinMaxValueRange;
        [NonSerialized] private bool m_NeedUpdateFilterData;
 
        public bool show
        {
            get { return m_Show; }
            set { if (PropertyUtil.SetStruct(ref m_Show, value)) SetAllDirty(); }
        }
        public AxisType type
        {
            get { return m_Type; }
            set { if (PropertyUtil.SetStruct(ref m_Type, value)) SetAllDirty(); }
        }
        public AxisMinMaxType minMaxType
        {
            get { return m_MinMaxType; }
            set { if (PropertyUtil.SetStruct(ref m_MinMaxType, value)) SetAllDirty(); }
        }
        public int gridIndex
        {
            get { return m_GridIndex; }
            set { if (PropertyUtil.SetStruct(ref m_GridIndex, value)) SetAllDirty(); }
        }
        public int polarIndex
        {
            get { return m_PolarIndex; }
            set { if (PropertyUtil.SetStruct(ref m_PolarIndex, value)) SetAllDirty(); }
        }
        public AxisPosition position
        {
            get { return m_Position; }
            set { if (PropertyUtil.SetStruct(ref m_Position, value)) SetAllDirty(); }
        }
        public float offset
        {
            get { return m_Offset; }
            set { if (PropertyUtil.SetStruct(ref m_Offset, value)) SetAllDirty(); }
        }
        public float min
        {
            get { return m_Min; }
            set { if (PropertyUtil.SetStruct(ref m_Min, value)) SetAllDirty(); }
        }
        public float max
        {
            get { return m_Max; }
            set { if (PropertyUtil.SetStruct(ref m_Max, value)) SetAllDirty(); }
        }
        public int splitNumber
        {
            get { return m_SplitNumber; }
            set { if (PropertyUtil.SetStruct(ref m_SplitNumber, value)) SetAllDirty(); }
        }
        public float interval
        {
            get { return m_Interval; }
            set { if (PropertyUtil.SetStruct(ref m_Interval, value)) SetAllDirty(); }
        }
        public bool boundaryGap
        {
            get { return IsCategory() ? m_BoundaryGap : false; }
            set { if (PropertyUtil.SetStruct(ref m_BoundaryGap, value)) SetAllDirty(); }
        }
        public float logBase
        {
            get { return m_LogBase; }
            set
            {
                if (value <= 0 || value == 1) value = 10;
                if (PropertyUtil.SetStruct(ref m_LogBase, value)) SetAllDirty();
            }
        }
        public bool logBaseE
        {
            get { return m_LogBaseE; }
            set { if (PropertyUtil.SetStruct(ref m_LogBaseE, value)) SetAllDirty(); }
        }
        public int maxCache
        {
            get { return m_MaxCache; }
            set { if (PropertyUtil.SetStruct(ref m_MaxCache, value < 0 ? 0 : value)) SetAllDirty(); }
        }
        public int ceilRate
        {
            get { return m_CeilRate; }
            set { if (PropertyUtil.SetStruct(ref m_CeilRate, value < 0 ? 0 : value)) SetAllDirty(); }
        }
        public bool inverse
        {
            get { return m_Inverse; }
            set { if (m_Type == AxisType.Value && PropertyUtil.SetStruct(ref m_Inverse, value)) SetAllDirty(); }
        }
        public bool clockwise
        {
            get { return m_Clockwise; }
            set { if (PropertyUtil.SetStruct(ref m_Clockwise, value)) SetAllDirty(); }
        }
        public List<string> data
        {
            get { return m_Data; }
            set { if (value != null) { m_Data = value; SetAllDirty(); } }
        }
        public List<Sprite> icons
        {
            get { return m_Icons; }
            set { if (value != null) { m_Icons = value; SetAllDirty(); } }
        }
        public AxisLine axisLine
        {
            get { return m_AxisLine; }
            set { if (value != null) { m_AxisLine = value; SetVerticesDirty(); } }
        }
        public AxisName axisName
        {
            get { return m_AxisName; }
            set { if (value != null) { m_AxisName = value; SetComponentDirty(); } }
        }
        public AxisTick axisTick
        {
            get { return m_AxisTick; }
            set { if (value != null) { m_AxisTick = value; SetVerticesDirty(); } }
        }
        public AxisLabel axisLabel
        {
            get { return m_AxisLabel; }
            set { if (value != null) { m_AxisLabel = value; SetComponentDirty(); } }
        }
        public AxisSplitLine splitLine
        {
            get { return m_SplitLine; }
            set { if (value != null) { m_SplitLine = value; SetVerticesDirty(); } }
        }
        public AxisSplitArea splitArea
        {
            get { return m_SplitArea; }
            set { if (value != null) { m_SplitArea = value; SetVerticesDirty(); } }
        }
        public bool insertDataToHead
        {
            get { return m_InsertDataToHead; }
            set { if (PropertyUtil.SetStruct(ref m_InsertDataToHead, value)) SetAllDirty(); }
        }
        public IconStyle iconStyle
        {
            get { return m_IconStyle; }
            set { if (PropertyUtil.SetClass(ref m_IconStyle, value)) SetAllDirty(); }
        }
        public override bool vertsDirty
        {
            get { return m_VertsDirty || axisLine.anyDirty || axisTick.anyDirty || splitLine.anyDirty || splitArea.anyDirty; }
        }
        public override bool componentDirty
        {
            get { return m_ComponentDirty || axisName.anyDirty || axisLabel.anyDirty; }
        }
        public override void ClearComponentDirty()
        {
            base.ClearComponentDirty();
            axisName.ClearComponentDirty();
            axisLabel.ClearComponentDirty();
        }
 
        public override void ClearVerticesDirty()
        {
            base.ClearVerticesDirty();
            axisLine.ClearVerticesDirty();
            axisTick.ClearVerticesDirty();
            splitLine.ClearVerticesDirty();
            splitArea.ClearVerticesDirty();
        }
        public int index { get; internal set; }
        public List<ChartLabel> runtimeAxisLabelList { get { return m_AxisLabelList; } set { m_AxisLabelList = value; } }
        public double runtimeMinValue
        {
            get { return m_RuntimeMinValue; }
            internal set
            {
                m_RuntimeMinValue = value;
                m_RuntimeLastMinValue = value;
                m_RuntimeMinValueUpdateTime = Time.time;
                m_RuntimeMinValueChanged = true;
            }
        }
        public double runtimeMaxValue
        {
            get { return m_RuntimeMaxValue; }
            internal set
            {
                m_RuntimeMaxValue = value;
                m_RuntimeLastMaxValue = value;
                m_RuntimeMaxValueUpdateTime = Time.time;
                m_RuntimeMaxValueChanged = false;
            }
        }
        public float runtimeZeroXOffset { get; internal set; }
        public float runtimeZeroYOffset { get; internal set; }
        public int runtimeMinLogIndex { get { return logBaseE ? (int)Math.Log(runtimeMinValue) : (int)Math.Log(runtimeMinValue, logBase); } }
        public int runtimeMaxLogIndex { get { return logBaseE ? (int)Math.Log(runtimeMaxValue) : (int)Math.Log(runtimeMaxValue, logBase); } }
        public bool runtimeLastCheckInverse { get; set; }
        public double runtimeMinMaxRange { get { return m_MinMaxValueRange; } set { m_MinMaxValueRange = value; } }
        public List<string> runtimeData { get { return m_RuntimeData; } }
        public float runtimeScaleWidth { get; internal set; }
        private int filterStart;
        private int filterEnd;
        private int filterMinShow;
        private List<string> filterData;
        private List<ChartLabel> m_AxisLabelList = new List<ChartLabel>();
        private GameObject m_TooltipLabel;
        private ChartText m_TooltipLabelText;
        private RectTransform m_TooltipLabelRect;
        private double m_RuntimeMinValue;
        private double m_RuntimeLastMinValue;
        private bool m_RuntimeMinValueChanged;
        private float m_RuntimeMinValueUpdateTime;
        private double m_RuntimeMaxValue;
        private double m_RuntimeLastMaxValue;
        private bool m_RuntimeMaxValueChanged;
        private float m_RuntimeMaxValueUpdateTime;
        private bool m_RuntimeMinValueFirstChanged = true;
        private bool m_RuntimeMaxValueFirstChanged = true;
        protected List<string> m_RuntimeData = new List<string>();
 
        public Axis Clone()
        {
            var axis = new Axis();
            axis.show = show;
            axis.type = type;
            axis.gridIndex = 0;
            axis.minMaxType = minMaxType;
            axis.min = min;
            axis.max = max;
            axis.splitNumber = splitNumber;
            axis.interval = interval;
            axis.boundaryGap = boundaryGap;
            axis.maxCache = maxCache;
            axis.logBase = logBase;
            axis.logBaseE = logBaseE;
            axis.ceilRate = ceilRate;
            axis.insertDataToHead = insertDataToHead;
            axis.iconStyle = iconStyle.Clone();
            axis.axisLine = axisLine.Clone();
            axis.axisName = axisName.Clone();
            axis.axisTick = axisTick.Clone();
            axis.axisLabel = axisLabel.Clone();
            axis.splitLine = splitLine.Clone();
            axis.splitArea = splitArea.Clone();
            axis.icons = new List<Sprite>();
            axis.data = new List<string>();
            ChartHelper.CopyList(axis.data, data);
            return axis;
        }
 
        public override void SetComponentDirty()
        {
            m_NeedUpdateFilterData = true;
            base.SetComponentDirty();
        }
 
        public void Copy(Axis axis)
        {
            show = axis.show;
            type = axis.type;
            minMaxType = axis.minMaxType;
            gridIndex = axis.gridIndex;
            min = axis.min;
            max = axis.max;
            splitNumber = axis.splitNumber;
            interval = axis.interval;
            boundaryGap = axis.boundaryGap;
            maxCache = axis.maxCache;
            logBase = axis.logBase;
            logBaseE = axis.logBaseE;
            ceilRate = axis.ceilRate;
            insertDataToHead = axis.insertDataToHead;
            iconStyle.Copy(axis.iconStyle);
            axisLine.Copy(axis.axisLine);
            axisName.Copy(axis.axisName);
            axisTick.Copy(axis.axisTick);
            axisLabel.Copy(axis.axisLabel);
            splitLine.Copy(axis.splitLine);
            splitArea.Copy(axis.splitArea);
            ChartHelper.CopyList(data, axis.data);
            ChartHelper.CopyList<Sprite>(icons, axis.icons);
        }
 
        public void ClearData()
        {
            m_Data.Clear();
            m_Icons.Clear();
            m_RuntimeData.Clear();
            SetAllDirty();
        }
 
        public bool IsCategory()
        {
            return type == AxisType.Category;
        }
 
        public bool IsValue()
        {
            return type == AxisType.Value;
        }
 
        public bool IsLog()
        {
            return type == AxisType.Log;
        }
 
        public bool IsTime()
        {
            return type == AxisType.Time;
        }
 
        public void SetNeedUpdateFilterData()
        {
            m_NeedUpdateFilterData = true;
        }
 
        public void AddData(string category)
        {
            if (maxCache > 0)
            {
                while (m_Data.Count >= maxCache)
                {
                    m_NeedUpdateFilterData = true;
                    m_Data.RemoveAt(m_InsertDataToHead ? m_Data.Count - 1 : 0);
                }
            }
            if (m_InsertDataToHead) m_Data.Insert(0, category);
            else m_Data.Add(category);
            SetAllDirty();
        }
 
        public void UpdateData(int index, string category)
        {
            if (index >= 0 && index < m_Data.Count)
            {
                m_Data[index] = category;
                SetComponentDirty();
            }
        }
 
        public void AddIcon(Sprite icon)
        {
            if (maxCache > 0)
            {
                while (m_Icons.Count > maxCache)
                {
                    m_Icons.RemoveAt(m_InsertDataToHead ? m_Icons.Count - 1 : 0);
                }
            }
            if (m_InsertDataToHead) m_Icons.Insert(0, icon);
            else m_Icons.Add(icon);
            SetAllDirty();
        }
 
        public void UpdateIcon(int index, Sprite icon)
        {
            if (index >= 0 && index < m_Icons.Count)
            {
                m_Icons[index] = icon;
                SetComponentDirty();
            }
        }
 
        public string GetData(int index)
        {
            if (index >= 0 && index < m_Data.Count)
                return m_Data[index];
            else
                return null;
        }
 
        public string GetData(int index, DataZoom dataZoom)
        {
            var showData = GetDataList(dataZoom);
            if (index >= 0 && index < showData.Count)
                return showData[index];
            else
                return "";
        }
 
        public Sprite GetIcon(int index)
        {
            if (index >= 0 && index < m_Icons.Count)
                return m_Icons[index];
            else
                return null;
        }
 
        internal List<string> GetDataList(DataZoom dataZoom)
        {
            if (dataZoom != null && dataZoom.enable && dataZoom.IsContainsAxis(this))
            {
                UpdateFilterData(dataZoom);
                return filterData;
            }
            else
            {
                return m_Data.Count > 0 ? m_Data : m_RuntimeData;
            }
        }
 
        internal List<string> GetDataList()
        {
            return m_Data.Count > 0 ? m_Data : m_RuntimeData;
        }
 
        private List<string> emptyFliter = new List<string>();
        internal void UpdateFilterData(DataZoom dataZoom)
        {
            if (dataZoom != null && dataZoom.enable && dataZoom.IsContainsAxis(this))
            {
                var data = GetDataList();
                var range = Mathf.RoundToInt(data.Count * (dataZoom.end - dataZoom.start) / 100);
                if (range <= 0) range = 1;
                int start = 0, end = 0;
                if (dataZoom.runtimeInvert)
                {
                    end = Mathf.CeilToInt(data.Count * dataZoom.end / 100);
                    start = end - range;
                    if (start < 0) start = 0;
                }
                else
                {
                    start = Mathf.FloorToInt(data.Count * dataZoom.start / 100);
                    end = start + range;
                    if (end > data.Count) end = data.Count;
                }
                if (start != filterStart || end != filterEnd || dataZoom.minShowNum != filterMinShow || m_NeedUpdateFilterData)
                {
                    filterStart = start;
                    filterEnd = end;
                    filterMinShow = dataZoom.minShowNum;
                    m_NeedUpdateFilterData = false;
                    if (data.Count > 0)
                    {
                        if (range < dataZoom.minShowNum)
                        {
                            if (dataZoom.minShowNum > data.Count) range = data.Count;
                            else range = dataZoom.minShowNum;
                        }
                        filterData = data.GetRange(start, range);
                    }
                    else
                    {
                        filterData = data;
                    }
                }
                else if (end == 0)
                {
                    filterData = emptyFliter;
                }
            }
        }
 
        internal int GetDataNumber(DataZoom dataZoom)
        {
            return GetDataList(dataZoom).Count;
        }
 
        internal void UpdateLabelText(float coordinateWidth, DataZoom dataZoom, bool forcePercent, float duration)
        {
            var minValue = GetCurrMinValue(duration);
            var maxValue = GetCurrMaxValue(duration);
            for (int i = 0; i < runtimeAxisLabelList.Count; i++)
            {
                if (runtimeAxisLabelList[i] != null)
                {
                    var text = AxisHelper.GetLabelName(this, coordinateWidth, i, minValue, maxValue, dataZoom, forcePercent);
                    runtimeAxisLabelList[i].SetText(text);
                }
            }
        }
 
        internal void SetTooltipLabel(GameObject label)
        {
            m_TooltipLabel = label;
            m_TooltipLabelRect = label.GetComponent<RectTransform>();
            m_TooltipLabelText = new ChartText(label);
            ChartHelper.SetActive(m_TooltipLabel, true);
        }
 
        internal void SetTooltipLabelColor(Color bgColor, Color textColor)
        {
            m_TooltipLabel.GetComponent<Image>().color = bgColor;
            m_TooltipLabelText.SetColor(textColor);
        }
 
        internal void SetTooltipLabelActive(bool flag)
        {
            if (m_TooltipLabel == null) return;
            ChartHelper.SetActive(m_TooltipLabel, flag);
        }
 
        internal void UpdateTooptipLabelText(string text)
        {
            if (m_TooltipLabelText != null)
            {
                m_TooltipLabelText.SetText(text);
                m_TooltipLabelRect.sizeDelta = new Vector2(m_TooltipLabelText.GetPreferredWidth() + 8,
                    m_TooltipLabelText.GetPreferredHeight() + 8);
            }
        }
 
        internal void UpdateTooltipLabelPos(Vector2 pos)
        {
            if (m_TooltipLabel)
            {
                m_TooltipLabel.transform.localPosition = pos;
            }
        }
 
        internal void UpdateMinValue(double value, bool check)
        {
            if (value != m_RuntimeMaxValue)
            {
                if (check && Application.isPlaying)
                {
                    if (m_RuntimeMinValueFirstChanged)
                    {
                        m_RuntimeMinValueFirstChanged = false;
                    }
                    else
                    {
                        m_RuntimeLastMinValue = m_RuntimeMinValue;
                        m_RuntimeMinValueChanged = true;
                        m_RuntimeMinValueUpdateTime = Time.time;
                    }
                    m_RuntimeMinValue = value;
                }
                else
                {
                    m_RuntimeMinValue = value;
                    m_RuntimeLastMinValue = value;
                    m_RuntimeMinValueUpdateTime = Time.time;
                    m_RuntimeMinValueChanged = true;
                }
            }
        }
 
        internal void UpdateMaxValue(double value, bool check)
        {
            if (value != m_RuntimeMaxValue)
            {
                if (check && Application.isPlaying)
                {
                    if (m_RuntimeMaxValueFirstChanged)
                    {
                        m_RuntimeMaxValueFirstChanged = false;
                    }
                    else
                    {
                        m_RuntimeLastMaxValue = m_RuntimeMaxValue;
                        m_RuntimeMaxValueChanged = true;
                        m_RuntimeMaxValueUpdateTime = Time.time;
                    }
                    m_RuntimeMaxValue = value;
                }
                else
                {
                    m_RuntimeMaxValue = value;
                    m_RuntimeLastMaxValue = value;
                    m_RuntimeMaxValueUpdateTime = Time.time;
                    m_RuntimeMaxValueChanged = false;
                }
            }
        }
 
        public double GetCurrMinValue(float duration)
        {
            if (!Application.isPlaying) return m_RuntimeMinValue;
            if (m_RuntimeMinValue == 0 && m_RuntimeMaxValue == 0) return 0;
            if (!m_RuntimeMinValueChanged) return m_RuntimeMinValue;
            var time = Time.time - m_RuntimeMinValueUpdateTime;
            if (time == 0) return m_RuntimeMinValue;
            var total = duration / 1000;
            if (duration > 0 && time <= total)
            {
                var curr = MathUtil.Lerp(m_RuntimeLastMinValue, m_RuntimeMinValue, time / total);
                return curr;
            }
            else
            {
                m_RuntimeMinValueChanged = false;
                return m_RuntimeMinValue;
            }
        }
 
        public double GetCurrMaxValue(float duration)
        {
            if (!Application.isPlaying) return m_RuntimeMaxValue;
            if (m_RuntimeMinValue == 0 && m_RuntimeMaxValue == 0) return 0;
            if (!m_RuntimeMaxValueChanged) return m_RuntimeMaxValue;
            var time = Time.time - m_RuntimeMaxValueUpdateTime;
            if (time == 0) return m_RuntimeMaxValue;
            var total = duration / 1000;
            if (duration > 0 && time < total)
            {
                var curr = MathUtil.Lerp(m_RuntimeLastMaxValue, m_RuntimeMaxValue, time / total);
                return curr;
            }
            else
            {
                m_RuntimeMaxValueChanged = false;
                return m_RuntimeMaxValue;
            }
        }
 
        public bool IsValueChanging(float duration)
        {
            if (!Application.isPlaying) return false;
            if (GetCurrMinValue(duration) != m_RuntimeMinValue || GetCurrMaxValue(duration) != m_RuntimeMaxValue)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
 
        public float GetLogValue(double value)
        {
            if (value <= 0 || value == 1) return 0;
            return logBaseE ? (float)Math.Log(value) : (float)Math.Log(value, logBase);
        }
 
        public bool IsLeft()
        {
            return position == AxisPosition.Left;
        }
 
        public bool IsRight()
        {
            return position == AxisPosition.Right;
        }
 
        public bool IsTop()
        {
            return position == AxisPosition.Top;
        }
 
        public bool IsBottom()
        {
            return position == AxisPosition.Bottom;
        }
    }
 
    [System.Serializable]
    public class XAxis : Axis
    {
        public static XAxis defaultXAxis
        {
            get
            {
                var axis = new XAxis
                {
                    m_Show = true,
                    m_Type = AxisType.Category,
                    m_Min = 0,
                    m_Max = 0,
                    m_SplitNumber = 5,
                    m_BoundaryGap = true,
                    m_Position = AxisPosition.Bottom,
                    m_Offset = 0,
                    m_Data = new List<string>()
                    {
                        "x1","x2","x3","x4","x5"
                    },
                    m_Icons = new List<Sprite>(5),
                };
                axis.splitLine.show = false;
                axis.splitLine.lineStyle.type = LineStyle.Type.None;
                axis.axisLabel.textLimit.enable = true;
                return axis;
            }
        }
    }
 
    [System.Serializable]
    public class YAxis : Axis
    {
        public static YAxis defaultYAxis
        {
            get
            {
                var axis = new YAxis
                {
                    m_Show = true,
                    m_Type = AxisType.Value,
                    m_Min = 0,
                    m_Max = 0,
                    m_SplitNumber = 5,
                    m_BoundaryGap = false,
                    m_Position = AxisPosition.Left,
                    m_Data = new List<string>(5),
 
                };
                axis.splitLine.show = true;
                axis.splitLine.lineStyle.type = LineStyle.Type.None;
                axis.axisLabel.textLimit.enable = false;
                return axis;
            }
        }
    }
 
    [System.Serializable]
    public class RadiusAxis : Axis
    {
        public static RadiusAxis defaultRadiusAxis
        {
            get
            {
                var axis = new RadiusAxis
                {
                    m_Show = true,
                    m_Type = AxisType.Value,
                    m_Min = 0,
                    m_Max = 0,
                    m_SplitNumber = 5,
                    m_BoundaryGap = false,
                    m_Data = new List<string>(5),
                };
                axis.splitLine.show = true;
                axis.splitLine.lineStyle.type = LineStyle.Type.Solid;
                axis.axisLabel.textLimit.enable = false;
                return axis;
            }
        }
    }
 
    [System.Serializable]
    public class AngleAxis : Axis
    {
        [SerializeField] private float m_StartAngle = 90;
 
        public float startAngle
        {
            get { return m_StartAngle; }
            set { if (PropertyUtil.SetStruct(ref m_StartAngle, value)) SetAllDirty(); }
        }
 
        public float runtimeStartAngle { get; set; }
 
        public static AngleAxis defaultAngleAxis
        {
            get
            {
                var axis = new AngleAxis
                {
                    m_Show = true,
                    m_Type = AxisType.Value,
                    m_SplitNumber = 12,
                    m_BoundaryGap = false,
                    m_Data = new List<string>(12),
                };
                axis.splitLine.show = true;
                axis.splitLine.lineStyle.type = LineStyle.Type.Solid;
                axis.axisLabel.textLimit.enable = false;
                axis.minMaxType = AxisMinMaxType.Custom;
                axis.min = 0;
                axis.max = 360;
                return axis;
            }
        }
    }
}