641 lines
21 KiB
C#
641 lines
21 KiB
C#
#define Graph_And_Chart_PRO
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.UI;
|
|
|
|
namespace ChartAndGraph
|
|
{
|
|
/// <summary>
|
|
/// Pie chart class
|
|
/// </summary>
|
|
[ExecuteInEditMode]
|
|
[Serializable]
|
|
public class PyramidChart : AnyChart
|
|
{
|
|
public class PyramidEventArgs
|
|
{
|
|
public PyramidEventArgs(string category, string title,string text)
|
|
{
|
|
Title = title;
|
|
Text = text;
|
|
Category = category;
|
|
}
|
|
public string Category { get; private set; }
|
|
public string Title { get; private set; }
|
|
public string Text { get; private set; }
|
|
}
|
|
|
|
public enum JustificationType
|
|
{
|
|
LeftAligned,
|
|
RightAligned,
|
|
CenterAligned
|
|
}
|
|
|
|
public enum SlopeType
|
|
{
|
|
Center,
|
|
Left,
|
|
Right,
|
|
Custom
|
|
}
|
|
|
|
bool mQuick = false;
|
|
[Serializable]
|
|
public class PyramidEvent : UnityEvent<PyramidEventArgs>
|
|
{
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// occures when a pie item is clicked
|
|
/// </summary>
|
|
public PyramidEvent ItemClicked = new PyramidEvent();
|
|
|
|
/// <summary>
|
|
/// occures when a pie item is hovered
|
|
/// </summary>
|
|
public PyramidEvent ItemHovered = new PyramidEvent();
|
|
|
|
/// <summary>
|
|
/// occurs when no pie is hovered any longer
|
|
/// </summary>
|
|
public UnityEvent NonHovered = new UnityEvent();
|
|
|
|
[SerializeField]
|
|
[Tooltip("The material of the back of the pyramid")]
|
|
public Material backMaterial;
|
|
|
|
|
|
/// <summary>
|
|
/// The inset of each pyramid component
|
|
/// </summary>
|
|
public Material BackMaterial
|
|
{
|
|
get { return backMaterial; }
|
|
set
|
|
{
|
|
backMaterial = value;
|
|
OnPropertyUpdated();
|
|
}
|
|
}
|
|
|
|
|
|
[SerializeField]
|
|
[Tooltip("The inset of each pyramid component")]
|
|
public float inset;
|
|
|
|
/// <summary>
|
|
/// The inset of each pyramid component
|
|
/// </summary>
|
|
public float Inset
|
|
{
|
|
get { return inset; }
|
|
set
|
|
{
|
|
inset = value;
|
|
OnPropertyUpdated();
|
|
}
|
|
}
|
|
|
|
|
|
[SerializeField]
|
|
[Tooltip("the text justification of the pyramid chart")]
|
|
private JustificationType justification;
|
|
|
|
/// <summary>
|
|
/// the text justification of the pyramid chart
|
|
/// </summary>
|
|
public JustificationType Justification
|
|
{
|
|
get { return justification; }
|
|
set
|
|
{
|
|
justification = value;
|
|
OnPropertyUpdated();
|
|
}
|
|
}
|
|
|
|
|
|
[SerializeField]
|
|
[Tooltip("the slope type of the pyramid")]
|
|
public SlopeType slope;
|
|
|
|
/// <summary>
|
|
/// prefab for the pie item. must contain a PieCanvasGenerator component
|
|
/// </summary>
|
|
public SlopeType Slope
|
|
{
|
|
get { return slope; }
|
|
set
|
|
{
|
|
slope = value;
|
|
OnPropertyUpdated();
|
|
}
|
|
}
|
|
|
|
|
|
[SerializeField]
|
|
[Tooltip("prefab for the pyramid item. must contain a PyramidCanvasGenerator component")]
|
|
private PyramidCanvasGenerator prefab;
|
|
|
|
|
|
/// <summary>
|
|
/// prefab for the pie item. must contain a PieCanvasGenerator component
|
|
/// </summary>
|
|
public PyramidCanvasGenerator Prefab
|
|
{
|
|
get { return prefab; }
|
|
set
|
|
{
|
|
prefab = value;
|
|
OnPropertyUpdated();
|
|
}
|
|
}
|
|
|
|
|
|
[HideInInspector]
|
|
[SerializeField]
|
|
private PyramidData Data = new PyramidData();
|
|
|
|
|
|
float totalWidth, totalHeight;
|
|
protected override IChartData DataLink
|
|
{
|
|
get
|
|
{
|
|
return Data;
|
|
}
|
|
}
|
|
|
|
public PyramidData DataSource
|
|
{
|
|
get { return Data; }
|
|
}
|
|
|
|
public override bool SupportRealtimeGeneration
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
protected override LegenedData LegendInfo
|
|
{
|
|
get
|
|
{
|
|
LegenedData legend = new LegenedData();
|
|
if (Data == null)
|
|
return legend;
|
|
foreach (var column in ((IInternalPyramidData)Data).InternalDataSource.Columns)
|
|
{
|
|
var item = new LegenedData.LegenedItem();
|
|
item.Name = column.Name;
|
|
if (column.Material != null)
|
|
item.Material = column.Material.Normal;
|
|
else
|
|
item.Material = null;
|
|
legend.AddLegenedItem(item);
|
|
}
|
|
return legend;
|
|
}
|
|
}
|
|
|
|
public PyramidChart()
|
|
{
|
|
|
|
}
|
|
|
|
public class PyramidObject
|
|
{
|
|
public string category;
|
|
public GameObject pyramidObject;
|
|
public GameObject backObject;
|
|
public IPyramidGenerator Generator;
|
|
public IPyramidGenerator BackGenerator;
|
|
public string Title, Text;
|
|
public BillboardText ItemLabel;
|
|
}
|
|
Dictionary<string, PyramidObject> mPyramids = new Dictionary<string, PyramidObject>();
|
|
void HookEvents()
|
|
{
|
|
Data.ProperyUpdated -= Data_ProperyUpdated;
|
|
Data.ProperyUpdated += Data_ProperyUpdated;
|
|
Data.RealtimeProperyUpdated -= Data_RealtimeProperyUpdated;
|
|
Data.RealtimeProperyUpdated += Data_RealtimeProperyUpdated;
|
|
|
|
((IInternalPyramidData)Data).InternalDataSource.DataStructureChanged -= MDataSource_DataStructureChanged;
|
|
((IInternalPyramidData)Data).InternalDataSource.DataStructureChanged += MDataSource_DataStructureChanged;
|
|
((IInternalPyramidData)Data).InternalDataSource.DataValueChanged -= MDataSource_DataValueChanged;
|
|
((IInternalPyramidData)Data).InternalDataSource.DataValueChanged += MDataSource_DataValueChanged;
|
|
}
|
|
|
|
private void Data_RealtimeProperyUpdated()
|
|
{
|
|
QuickInvalidate();
|
|
}
|
|
|
|
private void Data_ProperyUpdated()
|
|
{
|
|
Invalidate();
|
|
}
|
|
|
|
protected void QuickInvalidate()
|
|
{
|
|
if (Invalidating)
|
|
return;
|
|
Invalidate();
|
|
mQuick = true;
|
|
}
|
|
|
|
public override void Invalidate()
|
|
{
|
|
base.Invalidate();
|
|
mQuick = false;
|
|
}
|
|
|
|
private void MDataSource_DataValueChanged(object sender, DataSource.ChartDataSourceBase.DataValueChangedEventArgs e)
|
|
{
|
|
QuickInvalidate();
|
|
}
|
|
|
|
private void MDataSource_DataStructureChanged(object sender, EventArgs e)
|
|
{
|
|
Invalidate();
|
|
}
|
|
|
|
protected override void Start()
|
|
{
|
|
base.Start();
|
|
if (ChartCommon.IsInEditMode == false)
|
|
{
|
|
HookEvents();
|
|
}
|
|
Invalidate();
|
|
}
|
|
|
|
protected override void OnValidate()
|
|
{
|
|
base.OnValidate();
|
|
if (Application.isPlaying)
|
|
{
|
|
HookEvents();
|
|
}
|
|
Invalidate();
|
|
}
|
|
|
|
protected override void ClearChart()
|
|
{
|
|
base.ClearChart();
|
|
mPyramids.Clear();
|
|
}
|
|
|
|
Vector3 AlignTextPosition(AlignedItemLabels labels, PyramidObject obj, IPyramidGenerator generator,float height)
|
|
{
|
|
Vector3 position = new Vector3(labels.Location.Breadth, labels.Seperation, labels.Location.Depth);
|
|
position.y += height;
|
|
position = generator.GetTextPosition(justification, labels.Alignment == ChartLabelAlignment.Base);
|
|
return position;
|
|
}
|
|
|
|
protected IPyramidGenerator PreparePyramidObject(out GameObject pyramidObject)
|
|
{
|
|
if (Prefab == null)
|
|
pyramidObject = new GameObject();
|
|
else
|
|
pyramidObject = GameObject.Instantiate(Prefab.gameObject);
|
|
ChartCommon.HideObject(pyramidObject, hideHierarchy);
|
|
ChartCommon.EnsureComponent<RectTransform>(pyramidObject);
|
|
ChartCommon.EnsureComponent<CanvasRenderer>(pyramidObject);
|
|
return ChartCommon.EnsureComponent<PyramidCanvasGenerator>(pyramidObject);
|
|
}
|
|
|
|
private void GeneratePyramid(bool update)
|
|
{
|
|
if (update == false)
|
|
ClearChart();
|
|
else
|
|
EnsureTextController();
|
|
if (((IInternalPyramidData)Data).InternalDataSource == null)
|
|
return;
|
|
|
|
double[,] data = ((IInternalPyramidData)Data).InternalDataSource.getRawData();
|
|
int rowCount = data.GetLength(0);
|
|
int columnCount = data.GetLength(1);
|
|
|
|
if (rowCount != 1) // row count for pie must be 1
|
|
return;
|
|
|
|
double total = 0.0;
|
|
|
|
for (int i = 0; i < columnCount; ++i)
|
|
{
|
|
double val = Math.Max(data[0, i], 0);
|
|
total += val;
|
|
}
|
|
|
|
var rectTrans = GetComponent<RectTransform>();
|
|
totalHeight = rectTrans.rect.height;
|
|
totalWidth = rectTrans.rect.width;
|
|
|
|
float baseX1 = 0;
|
|
float baseX2 = totalWidth;
|
|
float accumilatedHeight = 0;
|
|
float? firstCenterHeight = null;
|
|
float acummilatedWeight = 0;
|
|
for (int i = 0; i < columnCount; ++i)
|
|
{
|
|
object userData = ((IInternalPyramidData)Data).InternalDataSource.Columns[i].UserData;
|
|
var categoryData = ((PyramidData.CategoryData)userData);
|
|
|
|
string name = ((IInternalPyramidData)Data).InternalDataSource.Columns[i].Name;
|
|
double amount = Math.Max(data[0, i], 0);
|
|
if (amount == 0f)
|
|
continue;
|
|
|
|
float weight = (float)(amount / total);
|
|
float actualHeight = totalHeight * weight;
|
|
|
|
float slopeRight = categoryData.RightSlope;
|
|
float slopeLeft = categoryData.LeftSlope;
|
|
float atan;
|
|
switch(slope)
|
|
{
|
|
case SlopeType.Center:
|
|
atan = -Mathf.Atan2(totalHeight, totalWidth * 0.5f) * Mathf.Rad2Deg +90;
|
|
slopeRight = atan;
|
|
slopeLeft = atan;
|
|
break;
|
|
case SlopeType.Left:
|
|
atan = -Mathf.Atan2(totalHeight, totalWidth) * Mathf.Rad2Deg + 90;
|
|
slopeLeft = 0;
|
|
slopeRight = atan;
|
|
break;
|
|
case SlopeType.Right:
|
|
atan = -Mathf.Atan2(totalHeight, totalWidth) * Mathf.Rad2Deg + 90;
|
|
slopeLeft = atan;
|
|
slopeRight = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
|
|
}
|
|
GameObject pyramidObject = null;
|
|
GameObject pyramidBackObject = null;
|
|
IPyramidGenerator generator = null;
|
|
IPyramidGenerator backgenerator = null;
|
|
PyramidObject dataObject;
|
|
float centerHeight = actualHeight * 0.5f + accumilatedHeight;
|
|
float unblendedHeight = centerHeight;
|
|
if (firstCenterHeight.HasValue == false)
|
|
firstCenterHeight = centerHeight;
|
|
centerHeight = Mathf.Lerp(firstCenterHeight.Value, centerHeight, categoryData.PositionBlend);
|
|
|
|
if (mPyramids.TryGetValue(name, out dataObject))
|
|
{
|
|
pyramidBackObject = dataObject.backObject;
|
|
pyramidObject = dataObject.pyramidObject;
|
|
backgenerator = dataObject.BackGenerator;
|
|
generator = dataObject.Generator;
|
|
generator.SetParams(baseX1, baseX2, totalWidth, slopeLeft, slopeRight, actualHeight,inset,0f,1f);
|
|
if (backgenerator !=null)
|
|
backgenerator.SetParams(baseX1, baseX2, totalWidth, slopeLeft, slopeRight, actualHeight, 0f, acummilatedWeight, acummilatedWeight + weight);
|
|
if (dataObject.ItemLabel)
|
|
{
|
|
Vector3 labelPos = AlignTextPosition(mItemLabels, dataObject,generator, centerHeight);
|
|
dataObject.ItemLabel.transform.localPosition = labelPos;
|
|
ChartCommon.UpdateTextParams(dataObject.ItemLabel.UIText, categoryData.Title);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dataObject = new PyramidObject();
|
|
|
|
if (backMaterial != null)
|
|
{
|
|
var backGenerator = PreparePyramidObject(out pyramidBackObject);
|
|
backGenerator.SetParams(baseX1, baseX2, totalWidth, slopeLeft, slopeRight, actualHeight, 0f, acummilatedWeight, acummilatedWeight +weight);
|
|
dataObject.backObject = pyramidBackObject;
|
|
dataObject.BackGenerator = backGenerator;
|
|
ChartCommon.HideObject(pyramidBackObject, hideHierarchy);
|
|
pyramidBackObject.transform.SetParent(transform,false);
|
|
ChartCommon.EnsureComponent<ChartItem>(pyramidBackObject);
|
|
ChartMaterialController backcontrol = ChartCommon.EnsureComponent<ChartMaterialController>(pyramidBackObject);
|
|
backcontrol.Materials = new ChartDynamicMaterial(backMaterial);
|
|
foreach(var itemEffect in pyramidBackObject.GetComponents<ChartItemEffect>())
|
|
ChartCommon.SafeDestroy(itemEffect);
|
|
ChartCommon.SafeDestroy(backGenerator.ContainerObject);
|
|
}
|
|
|
|
generator = PreparePyramidObject(out pyramidObject);
|
|
generator.SetParams(baseX1, baseX2, totalWidth, slopeLeft, slopeRight, actualHeight, inset,0f,1f);
|
|
ChartCommon.HideObject(pyramidObject, hideHierarchy);
|
|
pyramidObject.transform.SetParent(transform,false);
|
|
ChartCommon.EnsureComponent<ChartItem>(pyramidObject);
|
|
|
|
|
|
|
|
ChartMaterialController control = ChartCommon.EnsureComponent<ChartMaterialController>(pyramidObject);
|
|
control.Materials = Data.GetMaterial(name);
|
|
control.Refresh();
|
|
|
|
|
|
dataObject.Generator = generator;
|
|
dataObject.category = name;
|
|
dataObject.pyramidObject = pyramidObject;
|
|
mPyramids.Add(name, dataObject);
|
|
|
|
CharItemEffectController effect = ChartCommon.EnsureComponent<CharItemEffectController>(pyramidObject);
|
|
effect.WorkOnParent = false;
|
|
effect.InitialScale = false;
|
|
|
|
ChartItemEvents[] events = pyramidObject.GetComponentsInChildren<ChartItemEvents>();
|
|
for (int j = 0; j < events.Length; ++j)
|
|
{
|
|
if (events[j] == null)
|
|
continue;
|
|
InternalItemEvents comp = (InternalItemEvents)events[j];
|
|
comp.Parent = this;
|
|
comp.UserData = dataObject;
|
|
}
|
|
|
|
|
|
if (mItemLabels != null)
|
|
{
|
|
|
|
Vector3 labelPos = AlignTextPosition(mItemLabels, dataObject, generator, 0f);
|
|
float angle = justification == JustificationType.LeftAligned ? -180f : 180f;
|
|
BillboardText billboard = ChartCommon.CreateBillboardText(null, mItemLabels.TextPrefab, dataObject.pyramidObject.transform, categoryData.Title, labelPos.x, labelPos.y, labelPos.z, angle, null, hideHierarchy, mItemLabels.FontSize, mItemLabels.FontSharpness);
|
|
dataObject.ItemLabel = billboard;
|
|
dataObject.ItemLabel.transform.localPosition = labelPos;
|
|
TextController.AddText(billboard);
|
|
}
|
|
}
|
|
|
|
dataObject.Text = categoryData.Text;
|
|
dataObject.Title = categoryData.Title;
|
|
|
|
if (IsCanvas)
|
|
{
|
|
if (pyramidObject != null)
|
|
{
|
|
Vector2 actualPosition = new Vector2(0.5f, centerHeight) + categoryData.Shift;
|
|
actualPosition = new Vector2(actualPosition.x , actualPosition.y / TotalHeight);
|
|
var objectRect = pyramidObject.GetComponent<RectTransform>();
|
|
objectRect.pivot = new Vector2(0.5f, 0.5f);
|
|
objectRect.anchorMin = actualPosition;
|
|
objectRect.anchorMax = actualPosition;
|
|
objectRect.anchoredPosition = new Vector2();
|
|
objectRect.sizeDelta = new Vector2(totalWidth, actualHeight);
|
|
}
|
|
if(pyramidBackObject != null)
|
|
{
|
|
Vector2 actualPosition = new Vector2(0.5f, unblendedHeight);
|
|
actualPosition = new Vector2(actualPosition.x, actualPosition.y / TotalHeight);
|
|
var objectRect = pyramidBackObject.GetComponent<RectTransform>();
|
|
objectRect.pivot = new Vector2(0f, 0f);
|
|
objectRect.anchorMin = actualPosition;
|
|
objectRect.anchorMax = actualPosition;
|
|
objectRect.anchoredPosition = new Vector2();
|
|
}
|
|
}
|
|
accumilatedHeight += actualHeight;
|
|
acummilatedWeight += weight;
|
|
if(backgenerator!= null)
|
|
backgenerator.Generate();
|
|
generator.Generate();
|
|
generator.GetUpperBase(out baseX1, out baseX2);
|
|
generator.ApplyInfo(categoryData.Title, categoryData.Text, categoryData.Image,categoryData.Scale);
|
|
generator.SetAlpha(categoryData.Alpha);
|
|
}
|
|
}
|
|
|
|
protected override void OnLabelSettingChanged()
|
|
{
|
|
base.OnLabelSettingChanged();
|
|
Invalidate();
|
|
}
|
|
|
|
protected override void OnLabelSettingsSet()
|
|
{
|
|
base.OnLabelSettingsSet();
|
|
Invalidate();
|
|
}
|
|
|
|
public override void InternalGenerateChart()
|
|
{
|
|
if (gameObject.activeInHierarchy == false)
|
|
return;
|
|
base.InternalGenerateChart();
|
|
GeneratePyramid(mQuick);
|
|
mQuick = false;
|
|
}
|
|
|
|
protected override bool HasValues(AxisBase axis)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
protected override double MaxValue(AxisBase axis)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
protected override double MinValue(AxisBase axis)
|
|
{
|
|
return 0.0;
|
|
}
|
|
|
|
protected virtual void OnPropertyChanged()
|
|
{
|
|
QuickInvalidate();
|
|
}
|
|
|
|
protected override void OnPropertyUpdated()
|
|
{
|
|
base.OnPropertyUpdated();
|
|
Invalidate();
|
|
}
|
|
|
|
protected override void ValidateProperties()
|
|
{
|
|
base.ValidateProperties();
|
|
if (inset < 0)
|
|
inset = 0;
|
|
}
|
|
|
|
PyramidEventArgs userDataToEventArgs(object userData)
|
|
{
|
|
PyramidObject pyramid = (PyramidObject)userData;
|
|
return new PyramidEventArgs(pyramid.category, pyramid.Title,pyramid.Text);
|
|
}
|
|
|
|
protected override void OnNonHoverted()
|
|
{
|
|
base.OnNonHoverted();
|
|
if (NonHovered != null)
|
|
NonHovered.Invoke();
|
|
}
|
|
|
|
protected override void OnItemHoverted(object userData)
|
|
{
|
|
base.OnItemHoverted(userData);
|
|
if (ItemHovered != null)
|
|
ItemHovered.Invoke(userDataToEventArgs(userData));
|
|
}
|
|
|
|
protected override void OnItemSelected(object userData)
|
|
{
|
|
base.OnItemSelected(userData);
|
|
var args = userDataToEventArgs(userData);
|
|
if (ItemClicked != null)
|
|
ItemClicked.Invoke(args);
|
|
}
|
|
|
|
protected override void Update()
|
|
{
|
|
base.Update();
|
|
}
|
|
|
|
protected override bool SupportsCategoryLabels
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
protected override bool SupportsGroupLables
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
protected override bool SupportsItemLabels
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
protected override bool ShouldFitCanvas { get { return false; } }
|
|
|
|
protected override float TotalDepthLink { get { return 0f; } }
|
|
|
|
protected override float TotalHeightLink { get { return totalHeight; } }
|
|
|
|
protected override float TotalWidthLink { get { return totalWidth; } }
|
|
|
|
public override bool IsCanvas { get { return true; } }
|
|
}
|
|
}
|