public override void InternalGenerateChart()
{
RectTransform trans = GetComponent <RectTransform>();
if (FitToContainer)
{
float width = MessureWidth();
heightRatio = width * (trans.rect.size.y / trans.rect.size.x);
}
base.InternalGenerateChart();
if (TextController != null && TextController.gameObject)
{
TextController.gameObject.transform.SetAsLastSibling();
}
float widthScale = trans.rect.size.x / TotalWidth;
float heightScale = trans.rect.size.y / HeightRatio;
GameObject fixPosition = new GameObject();
ChartCommon.HideObject(fixPosition, hideHierarchy);
fixPosition.AddComponent <ChartItem>();
fixPosition.transform.position = transform.position;
while (gameObject.transform.childCount > 0)
{
transform.GetChild(0).SetParent(fixPosition.transform, false);
}
fixPosition.transform.SetParent(transform, false);
fixPosition.transform.localScale = new Vector3(1f, 1f, 1f);
float uniformScale = Math.Min(widthScale, heightScale);
fixPosition.transform.localScale = new Vector3(uniformScale, uniformScale, uniformScale);
fixPosition.transform.localPosition = new Vector3(-TotalWidth * uniformScale * 0.5f, -HeightRatio * uniformScale * 0.5f, 0f);
mLastSetSize = trans.rect.size;
}
protected override GameObject CreateAxisObject(float thickness, Vector3[] path)
{
Vector3[] newPath = new Vector3[path.Length + 1];
path.CopyTo(newPath, 0);
newPath[path.Length] = path[0];
path = newPath;
List <CanvasLines.LineSegement> seg = new List <CanvasLines.LineSegement>();
seg.Add(new CanvasLines.LineSegement(path));
GameObject conatiner = ChartCommon.CreateChartItem();
ChartCommon.HideObject(conatiner, hideHierarchy);
conatiner.transform.SetParent(transform, false);
conatiner.transform.localScale = new Vector3(1f, 1f, 1f);
conatiner.transform.localPosition = Vector3.zero;
conatiner.transform.localRotation = Quaternion.identity;
if (AxisLineMaterial != null && AxisThickness > 0f)
{
CanvasLines lines = CreateLinesObject(conatiner);
lines.material = AxisLineMaterial;
lines.Thickness = thickness;
lines.SetLines(seg);
}
if (AxisPointMaterial != null && AxisPointSize > 0f)
{
CanvasLines points = CreateLinesObject(conatiner);
points.material = AxisPointMaterial;
points.MakePointRender(AxisPointSize);
points.SetLines(seg);
}
return(conatiner);
}
protected GameObject CreateRectMask(Rect viewRect)
{
GameObject obj = Instantiate(Resources.Load("Chart And Graph/RectMask") as GameObject);
ChartCommon.HideObject(obj, hideHierarchy);
obj.AddComponent <ChartItem>();
obj.transform.SetParent(transform, false);
var rectTransform = obj.GetComponent <RectTransform>();
rectTransform.anchorMin = new Vector2(0f, 0f);
rectTransform.anchorMax = new Vector2(0f, 0f);
rectTransform.pivot = new Vector2(0f, 1f);
rectTransform.sizeDelta = viewRect.size;
rectTransform.anchoredPosition = new Vector2(0f, viewRect.size.y);
Mask m = obj.GetComponent <Mask>();
if (m != null)
{
m.enabled = Scrollable;
}
Image im = obj.GetComponent <Image>();
im.raycastTarget = raycastTarget;
if (im != null)
{
im.enabled = Scrollable;
}
mMask = obj;
return(obj);
}
/// <summary>
///
/// </summary>
/// <param name="t"></param>
/// <param name="prefab"></param>
/// <returns></returns>
ScrollableAxisChart IMixedChartDelegate.CreateCategoryView(Type t, ScrollableAxisChart prefab)
{
string type = t.FullName;
ScrollableAxisChart chart = prefab;
if (chart == null)
{
if (mPrefabs == null || mPrefabs.TryGetValue(type, out chart) == false)
{
return(null);
}
}
if (chart.IsCanvas != IsCanvas)
{
return(null);
}
GameObject obj = (GameObject)GameObject.Instantiate(chart.gameObject);
obj.transform.SetParent(transform);
ChartCommon.HideObject(obj, true);
chart = obj.GetComponent <ScrollableAxisChart>();
mContainedCharts.Add(chart);
return(chart);
}
private GameObject CreatePointObject(GraphData.CategoryData data)
{
GameObject prefab = data.DotPrefab;
if (prefab == null)
{
if (mEmptyPointPrefab == null)
{
mEmptyPointPrefab = (GameObject)Resources.Load("Chart And Graph/SelectHandle");
}
prefab = mEmptyPointPrefab;
}
GameObject obj = GameObject.Instantiate(prefab);
ChartCommon.HideObject(obj, hideHierarchy);
if (obj.GetComponent <ChartItem>() == null)
{
obj.AddComponent <ChartItem>();
}
obj.transform.SetParent(transform);
obj.transform.localScale = new Vector3(1f, 1f, 1f);
obj.transform.localPosition = Vector3.zero;
obj.transform.localRotation = Quaternion.identity;
return(obj);
}
/* internal static BillboardText CreateBillboardText(Text prefab, Transform parentTransform, string text, float x, float y, float z, float angle, bool hideHirarechy, int fontSize, float sharpness)
* {
* return CreateBillboardText(prefab, parentTransform, text, x, y, z, angle, null, hideHirarechy, fontSize, sharpness);
* }*/
internal static BillboardText UpdateBillboardText(BillboardText billboardText, Transform parentTransform, string text, float x, float y, float z, float angle, Transform relativeFrom, bool hideHirarechy, bool yMirror)
{
GameObject UIText = billboardText.UIText.gameObject;
GameObject billboard = billboardText.gameObject;
ChartCommon.HideObject(billboard, hideHirarechy);
TextDirection direction = UIText.GetComponent <TextDirection>();
GameObject TextObj = billboardText.UIText;
billboardText.YMirror = yMirror;
if (direction != null)
{
TextObj = direction.Text.gameObject;
if (relativeFrom != null)
{
direction.SetRelativeTo(relativeFrom, billboard.transform);
}
// else
direction.SetDirection(angle);
}
// if (parentTransform != null && billboard.transform.parent != parentTransform)
// {
// billboard.transform.SetParent(parentTransform, false);
// }
UpdateTextParams(TextObj, text);
billboard.transform.localPosition = new Vector3(x, y, z);
return(billboardText);
}
void FitCanvas()
{
RectTransform trans = GetComponent <RectTransform>();
mLastSetSize = trans.rect.size;
if (FitAspectCanvas == false)
{
return;
}
GameObject fixPosition = new GameObject();
mFixPosition = fixPosition;
ChartCommon.HideObject(fixPosition, hideHierarchy);
// fixPosition.AddComponent<ChartItem>();
// var fixPositionRect = fixPosition.GetComponent<RectTransform>();
// fixPositionRect.anchorMin = new Vector2(1f, 1f);
// fixPositionRect.anchorMax = new Vector2(1f, 1f);
fixPosition.transform.position = transform.position;
while (gameObject.transform.childCount > 0)
{
transform.GetChild(0).SetParent(fixPosition.transform, false);
}
fixPosition.transform.SetParent(transform, false);
fixPosition.transform.localScale = new Vector3(1f, 1f, 1f);
float widthScale = trans.rect.size.x / TotalWidthLink;
float heightScale = trans.rect.size.y / TotalHeightLink;
float uniformScale = Math.Min(widthScale, heightScale);
fixPosition.transform.localScale = new Vector3(uniformScale, uniformScale, uniformScale);
Vector3 offs = CanvasFitOffset;
fixPosition.transform.localPosition = new Vector3(-TotalWidthLink * uniformScale * offs.x, -TotalHeightLink * uniformScale * offs.y, 0f);
}
private CanvasLines CreateDataObject(GraphData.CategoryData data, GameObject rectMask)
{
GameObject obj = new GameObject("Lines", typeof(RectTransform));
ChartCommon.HideObject(obj, hideHierarchy);
obj.AddComponent <ChartItem>();
RectTransform t = obj.GetComponent <RectTransform>();
obj.AddComponent <CanvasRenderer>();
// Canvas c = obj.AddComponent<Canvas>();
//c.pixelPerfect = false;
//obj.AddComponent<GraphicRaycaster>();
CanvasLines lines = obj.AddComponent <CanvasLines>();
lines.maskable = true;
t.SetParent(rectMask.transform, false);
t.localScale = new Vector3(1f, 1f, 1f);
t.anchorMin = new Vector2(0f, 0f);
t.anchorMax = new Vector2(0f, 0f);
t.anchoredPosition = Vector3.zero;
t.localRotation = Quaternion.identity;
return(lines);
}
internal protected virtual IAxisGenerator InternalUpdateAxis(ref GameObject axisObject, AxisBase axisBase, ChartOrientation axisOrientation, bool isSubDiv, bool forceRecreate, double scrollOffset)
{
IAxisGenerator res = null;
if (axisObject == null || forceRecreate || CanvasChanged)
{
ChartCommon.SafeDestroy(axisObject);
GameObject axis = null;
if (IsUnderCanvas)
{
axis = ChartCommon.CreateCanvasChartItem();
axis.transform.SetParent(transform, false);
var rect = axis.GetComponent <RectTransform>();
rect.anchorMin = new Vector2(0f, 0f);
rect.anchorMax = new Vector2(0f, 0f);
rect.localScale = new Vector3(1f, 1f, 1f);
rect.localRotation = Quaternion.identity;
rect.anchoredPosition = new Vector3();
}
else
{
axis = ChartCommon.CreateChartItem();
axis.transform.SetParent(transform, false);
axis.transform.localScale = new Vector3(1f, 1f, 1f);
axis.transform.localRotation = Quaternion.identity;
axis.transform.localPosition = new Vector3();
}
axisBase.ClearFormats();
axis.layer = gameObject.layer; // put the axis on the same layer as the chart
ChartCommon.HideObject(axis, hideHierarchy);
axisObject = axis;
if (IsUnderCanvas)
{
res = axis.AddComponent <CanvasAxisGenerator>();
}
else
{
res = axis.AddComponent <AxisGenerator>();
}
}
else
{
if (IsUnderCanvas)
{
res = axisObject.GetComponent <CanvasAxisGenerator>();
}
else
{
res = axisObject.GetComponent <AxisGenerator>();
}
}
res.SetAxis(scrollOffset, this, axisBase, axisOrientation, isSubDiv);
// axisObject.transform.localScale = new Vector3(1f, 1f, 1f);
// axisObject.transform.localRotation = Quaternion.identity;
// axisObject.transform.localPosition = new Vector3();
return(res);
}
protected GameObject CreatePrefab(GameObject container, GameObject prefab)
{
GameObject obj = GameObject.Instantiate(prefab);
ChartCommon.HideObject(obj, hideHierarchy);
ChartCommon.EnsureComponent <ChartItem>(obj);
obj.transform.SetParent(container.transform, false);
obj.transform.localScale = new Vector3(1f, 1f, 1f);
obj.transform.localPosition = Vector3.zero;
obj.transform.localRotation = Quaternion.identity;
return(obj);
}
/// <summary>
/// generates a text controller object for this chart
/// </summary>
void CreateTextController()
{
GameObject obj = new GameObject("textController", typeof(RectTransform));;
ChartCommon.HideObject(obj, hideHierarchy);
obj.transform.SetParent(transform);
obj.transform.localScale = new Vector3(1f, 1f, 1f);
obj.transform.localRotation = Quaternion.identity;
obj.transform.localPosition = Vector3.zero;
TextController = obj.AddComponent <TextController>();
TextController.mParent = this;
}
protected RadarFillGenerator CreateFillObject(GameObject conatiner)
{
GameObject obj = ChartCommon.CreateChartItem();
ChartCommon.HideObject(obj, hideHierarchy);
obj.AddComponent <ChartItem>();
RadarFillGenerator fill = obj.AddComponent <RadarFillGenerator>();
obj.transform.SetParent(conatiner.transform, false);
obj.transform.localScale = new Vector3(1f, 1f, 1f);
obj.transform.localPosition = Vector3.zero;
obj.transform.localRotation = Quaternion.identity;
return(fill);
}
void FitCanvas()
{
RectTransform trans = GetComponent <RectTransform>();
mLastSetSize = trans.rect.size;
if (FitAspectCanvas == false)
{
return;
}
ChartMagin margin = MarginLink;
if (mFixPosition != null)
{
ChartCommon.SafeDestroy(mFixPosition);
}
GameObject fixPosition = new GameObject();
mFixPosition = fixPosition;
ChartCommon.HideObject(fixPosition, hideHierarchy);
// fixPosition.AddComponent<ChartItem>();
// var fixPositionRect = fixPosition.GetComponent<RectTransform>();
// fixPositionRect.anchorMin = new Vector2(1f, 1f);
// fixPositionRect.anchorMax = new Vector2(1f, 1f);
fixPosition.transform.position = transform.position;
while (gameObject.transform.childCount > 0)
{
transform.GetChild(0).SetParent(fixPosition.transform, false);
}
fixPosition.transform.SetParent(transform, false);
fixPosition.transform.localScale = new Vector3(1f, 1f, 1f);
float totalWidth = TotalWidthLink; // + margin.Left + margin.Right;
float totalHeight = TotalHeightLink; // + margin.Top + margin.Bottom;
float widthScale = (trans.rect.size.x - margin.Left - margin.Right) / totalWidth;
float heightScale = (trans.rect.size.y - margin.Top - margin.Bottom) / totalHeight;
float uniformScale = Math.Min(widthScale, heightScale);
fixPosition.transform.localScale = new Vector3(uniformScale, uniformScale, uniformScale);
if (MaintainLabelSize)
{
TextController.SetInnerScale(1f / uniformScale);
}
else
{
TextController.SetInnerScale(1f);
}
Vector3 offs = CanvasFitOffset;
fixPosition.transform.localPosition = new Vector3(-totalWidth * uniformScale * offs.x + Mathf.Lerp(margin.Left, -margin.Right, offs.x), -totalHeight * uniformScale * offs.y - Mathf.Lerp(margin.Top, -margin.Bottom, offs.y), 0f);
}
protected CanvasLines CreateLinesObject(GameObject conatiner)
{
GameObject obj = ChartCommon.CreateCanvasChartItem();
ChartCommon.HideObject(obj, hideHierarchy);
obj.AddComponent <ChartItem>();
obj.AddComponent <CanvasRenderer>();
CanvasLines lines = obj.AddComponent <CanvasLines>();
obj.transform.SetParent(conatiner.transform, false);
obj.transform.localScale = new Vector3(1f, 1f, 1f);
obj.transform.localPosition = Vector3.zero;
obj.transform.localRotation = Quaternion.identity;
return(lines);
}
private PathGenerator CreateLineObject(GraphData.CategoryData data)
{
GameObject obj = GameObject.Instantiate(data.LinePrefab.gameObject);
ChartCommon.HideObject(obj, hideHierarchy);
PathGenerator lines = obj.GetComponent <PathGenerator>();
if (obj.GetComponent <ChartItem>() == null)
{
obj.AddComponent <ChartItem>();
}
obj.transform.SetParent(transform);
obj.transform.localScale = new Vector3(1f, 1f, 1f);
obj.transform.localPosition = Vector3.zero;
obj.transform.localRotation = Quaternion.identity;
return(lines);
}
private CanvasCandle CreateDataObject(CandleChartData.CategoryData data, GameObject rectMask)
{
GameObject obj = new GameObject("Candles", typeof(RectTransform));
ChartCommon.HideObject(obj, hideHierarchy);
obj.AddComponent <ChartItem>();
RectTransform t = obj.GetComponent <RectTransform>();
obj.AddComponent <CanvasRenderer>();
CanvasCandle candles = obj.AddComponent <CanvasCandle>();
t.SetParent(rectMask.transform, false);
t.localScale = new Vector3(1f, 1f, 1f);
t.anchorMin = new Vector2(0f, 0f);
t.anchorMax = new Vector2(0f, 0f);
t.anchoredPosition = Vector3.zero;
t.localRotation = Quaternion.identity;
return(candles);
}
protected override GameObject CreateAxisObject(float thickness, Vector3[] path)
{
GameObject obj = ChartCommon.CreateChartItem();
ChartCommon.HideObject(obj, true);
if (AxisPrefab != null && AxisThickness > 0.0001f)
{
GameObject axis = GameObject.Instantiate(AxisPrefab.gameObject);
axis.AddComponent <ChartItem>();
ChartCommon.HideObject(axis, hideHierarchy);
axis.transform.SetParent(obj.transform, true);
axis.transform.localScale = new Vector3(1f, 1f, 1f);
axis.transform.localPosition = Vector3.zero;
axis.transform.rotation = Quaternion.identity;
Renderer rend = axis.GetComponent <Renderer>();
if (rend != null && AxisLineMaterial != null)
{
rend.material = AxisLineMaterial;
}
PathGenerator gen = axis.GetComponent <PathGenerator>();
gen.Generator(path, thickness, true);
}
if (AxisPointPrefab != null && AxisPointSize > 0.0001f)
{
for (int i = 0; i < path.Length; i++)
{
GameObject point = GameObject.Instantiate(AxisPointPrefab.gameObject);
point.transform.SetParent(obj.transform, true);
point.transform.localScale = new Vector3(AxisPointSize, AxisPointSize, AxisPointSize);
point.transform.localPosition = path[i];
point.transform.rotation = Quaternion.identity;
Renderer rend = point.GetComponent <Renderer>();
if (rend != null && AxisPointMaterial != null)
{
rend.material = AxisPointMaterial;
}
}
}
return(obj);
}
private CanvasLines CreateDataObject(GraphData.CategoryData data, GameObject rectMask, bool mask)
{
GameObject obj = new GameObject("Lines", typeof(RectTransform));
ChartCommon.HideObject(obj, hideHierarchy);
obj.AddComponent <ChartItem>();
var rend = obj.AddComponent <CanvasRenderer>();
rend.cullTransparentMesh = false;
CenterObject(obj, rectMask.GetComponent <RectTransform>());
// Canvas c = obj.AddComponent<Canvas>();
//c.pixelPerfect = false;
//obj.AddComponent<GraphicRaycaster>();
CanvasLines lines = obj.AddComponent <CanvasLines>();
lines.maskable = true;
return(lines);
}
protected GameObject CreateRectMask(Rect viewRect)
{
//GameObject obj = Instantiate(Resources.Load("Chart And Graph/RectMask") as GameObject);
GameObject obj = ChartCommon.CreateCanvasChartItem();
obj.name = "rectMask2D";;
ChartCommon.HideObject(obj, hideHierarchy);
obj.AddComponent <RectMask2D>();
//obj.AddComponent<ChartItem>();
obj.transform.SetParent(transform, false);
var rectTransform = obj.GetComponent <RectTransform>();
rectTransform.anchorMin = new Vector2(0f, 0f);
rectTransform.anchorMax = new Vector2(0f, 0f);
rectTransform.pivot = new Vector2(0f, 1f);
rectTransform.sizeDelta = viewRect.size;
rectTransform.anchoredPosition = new Vector2(0f, viewRect.size.y);
mMask = obj;
return(obj);
}
void FitCanvas()
{
RectTransform trans = GetComponent <RectTransform>();
GameObject fixPosition = new GameObject();
mFixPosition = fixPosition;
ChartCommon.HideObject(fixPosition, hideHierarchy);
fixPosition.AddComponent <ChartItem>();
fixPosition.transform.position = transform.position;
while (gameObject.transform.childCount > 0)
{
transform.GetChild(0).SetParent(fixPosition.transform, false);
}
fixPosition.transform.SetParent(transform, false);
fixPosition.transform.localScale = new Vector3(1f, 1f, 1f);
float widthScale = trans.rect.size.x / WidthRatio;
float heightScale = trans.rect.size.y / HeightRatio;
float uniformScale = Math.Min(widthScale, heightScale);
fixPosition.transform.localScale = new Vector3(uniformScale, uniformScale, uniformScale);
fixPosition.transform.localPosition = new Vector3(-WidthRatio * uniformScale * 0.5f, -HeightRatio * uniformScale * 0.5f, 0f);
mLastSetSize = trans.rect.size;
}
void FitCanvas()
{
RectTransform trans = GetComponent <RectTransform>();
mLastSetSize = trans.rect.size;
if (ShouldFitCanvas == false)
{
return;
}
// if (FitAspectCanvas == FitType.None)
// return;
ChartMagin margin = MarginLink;
if (mFixPosition != null)
{
ChartCommon.SafeDestroy(mFixPosition);
}
GameObject fixPosition = new GameObject();
var fixRect = fixPosition.AddComponent <RectTransform>();
mFixPosition = fixPosition;
ChartCommon.HideObject(fixPosition, hideHierarchy);
fixPosition.AddComponent <ChartItem>();
float totalWidth = TotalWidthLink; // + margin.Left + margin.Right;
float totalHeight = TotalHeightLink; // + margin.Top + margin.Bottom;
fixRect.SetParent(transform, false);
fixRect.localPosition = Vector3.zero;
fixRect.anchorMin = new Vector2(0f, 0f);
fixRect.anchorMax = new Vector2(0f, 0f);
fixRect.pivot = new Vector2(0f, 0f);
fixRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, totalWidth);
fixRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, totalHeight);
float xAnchor = 0.5f;
float yAnchor = 0.5f;
if (FitAlignCanvas == FitAlign.StartXCenterY || FitAlignCanvas == FitAlign.StartXStartY)
{
xAnchor = 0f;
}
if (FitAlignCanvas == FitAlign.CenterXStartY || FitAlignCanvas == FitAlign.StartXStartY)
{
yAnchor = 0f;
}
fixPosition.transform.localScale = new Vector3(1f, 1f, 1f);
fixPosition.transform.SetSiblingIndex(0);
toMove.Clear();
for (int i = 0; i < gameObject.transform.childCount; i++)
{
var child = trans.GetChild(i).gameObject;
if (child == null)
{
continue;
}
if (child == fixPosition)
{
continue;
}
if (child.GetComponent <AnyChart>() != null)
{
continue;
}
if (child.GetComponent <ChartItem>() == null)
{
continue;
}
toMove.Add(child);
}
foreach (GameObject obj in toMove)
{
obj.transform.SetParent(fixPosition.transform, false);
}
toMove.Clear();
fixRect.anchorMin = new Vector2(xAnchor, yAnchor);
fixRect.anchorMax = new Vector2(xAnchor, yAnchor);
fixRect.pivot = new Vector2(xAnchor, yAnchor);
if (totalWidth <= 0 || TotalHeight <= 0)
{
return;
}
float widthScale = (trans.rect.size.x - margin.Left - margin.Right) / totalWidth;
float heightScale = (trans.rect.size.y - margin.Top - margin.Bottom) / totalHeight;
float uniformScale = Math.Min(widthScale, heightScale);
if (FitAspectCanvas == FitType.Height)
{
uniformScale = heightScale;
}
else if (FitAspectCanvas == FitType.Width)
{
uniformScale = widthScale;
}
else if (FitAspectCanvas == FitType.None)
{
uniformScale = 1f;
}
fixRect.localScale = new Vector3(uniformScale, uniformScale, 1f);
if (MaintainLabelSize)
{
TextController.SetInnerScale(1f / uniformScale);
}
else
{
TextController.SetInnerScale(1f);
}
fixRect.anchoredPosition = new Vector3(Mathf.Lerp(margin.Left, -margin.Right, xAnchor), Mathf.Lerp(margin.Bottom, -margin.Top, yAnchor), 0f);
}
protected override GameObject CreateCategoryObject(Vector3[] path, int category)
{
RadarChartData.CategoryData cat = ((IInternalRadarData)DataSource).getCategoryData(category);
GameObject container = ChartCommon.CreateChartItem();
ChartCommon.HideObject(container, hideHierarchy);
container.transform.SetParent(transform, false);
container.transform.localScale = new Vector3(1f, 1f, 1f);
container.transform.localPosition = new Vector3(0f, 0f, cat.Seperation);
container.transform.localRotation = Quaternion.identity;
if (cat.FillMaterial != null)
{
RadarFillGenerator fill = CreateFillObject(container);
fill.Smoothing = cat.FillSmoothing;
Renderer rend = fill.GetComponent <Renderer>();
if (rend != null)
{
rend.material = cat.FillMaterial;
}
fill.Generate(path, Radius, cat.Curve);
}
if (cat.LinePrefab != null && cat.LineMaterial != null && cat.LineThickness > 0)
{
GameObject line = CreatePrefab(container, cat.LinePrefab.gameObject);
PathGenerator pathGen = line.GetComponent <PathGenerator>();
Renderer rend = line.GetComponent <Renderer>();
if (rend != null)
{
rend.material = cat.LineMaterial;
}
pathGen.Generator(path, cat.LineThickness, true);
}
GameObject prefab = cat.PointPrefab;
if (prefab == null)
{
if (mEmptyPointPrefab == null)
{
mEmptyPointPrefab = (GameObject)Resources.Load("Chart And Graph/SelectHandle");
}
prefab = mEmptyPointPrefab;
}
if (prefab != null)
{
for (int i = 0; i < path.Length; i++)
{
GameObject point = CreatePrefab(container, prefab);
string group = DataSource.GetGroupName(i);
double value = DataSource.GetValue(cat.Name, group);
RadarEventArgs args = new RadarEventArgs(cat.Name, group, value, path[i], i);
point.transform.localPosition = path[i];
point.transform.localScale = new Vector3(cat.PointSize, cat.PointSize, cat.PointSize);
Renderer rend = point.GetComponent <Renderer>();
if (rend != null)
{
rend.material = cat.PointMaterial;
}
ChartMaterialController controller = point.GetComponent <ChartMaterialController>();
if (controller != null && controller.Materials != null)
{
Color hover = controller.Materials.Hover;
Color selected = controller.Materials.Selected;
controller.Materials = new ChartDynamicMaterial(cat.PointMaterial, hover, selected);
}
ChartItemEvents[] events = point.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 = args;
}
}
}
if (mCategoryLabels != null && mCategoryLabels.isActiveAndEnabled)
{
for (int i = 0; i < path.Length; i++)
{
string group = DataSource.GetGroupName(i);
double val = DataSource.GetValue(cat.Name, group);
Vector3 labelPos = path[i];
Vector3 dir = labelPos.normalized;
labelPos += dir * mCategoryLabels.Seperation;
labelPos += new Vector3(mCategoryLabels.Location.Breadth, 0f, mCategoryLabels.Location.Depth);
int fractionDigits = 2;
if (mItemLabels != null)
{
fractionDigits = mItemLabels.FractionDigits;
}
string toSet = mCategoryLabels.TextFormat.Format(ChartAdancedSettings.Instance.FormatFractionDigits(fractionDigits, val), cat.Name, group);
BillboardText billboard = ChartCommon.CreateBillboardText(null, mCategoryLabels.TextPrefab, transform, toSet, labelPos.x, labelPos.y, labelPos.z, 0f, null, hideHierarchy, mCategoryLabels.FontSize, mCategoryLabels.FontSharpness);
TextController.AddText(billboard);
AddBillboardText(cat.Name, billboard);
}
}
return(container);
}
internal static BillboardText CreateBillboardText(BillboardText item, MonoBehaviour prefab, Transform parentTransform, string text, float x, float y, float z, float angle, Transform relativeFrom, bool hideHirarechy, int fontSize, float sharpness)
{
if (item != null)
{
return(UpdateBillboardText(item, parentTransform, text, x, y, z, angle, relativeFrom, hideHirarechy, prefab != null && prefab.transform.localScale.y < 0));
}
if (prefab == null || prefab.gameObject == null)
{
GameObject g = Resources.Load("Chart And Graph/DefaultText") as GameObject;
prefab = g.GetComponent <Text>();
}
GameObject UIText = (GameObject)GameObject.Instantiate(prefab.gameObject);
GameObject billboard = new GameObject();
ChartCommon.HideObject(billboard, hideHirarechy);
if (parentTransform.GetComponent <RectTransform>())
{
billboard.AddComponent <RectTransform>();
}
if (parentTransform != null)
{
billboard.transform.SetParent(parentTransform, false);
UIText.transform.SetParent(parentTransform, false);
}
BillboardText billboardText = billboard.AddComponent <BillboardText>();
billboard.AddComponent <ChartItem>();
TextDirection direction = UIText.GetComponent <TextDirection>();
GameObject obj = null;
if (direction != null)
{
obj = direction.Text.gameObject;
if (relativeFrom != null)
{
direction.SetRelativeTo(relativeFrom, billboard.transform);
}
// else
direction.SetDirection(angle);
}
if (obj == null)
{
obj = UIText;
}
sharpness = Mathf.Clamp(sharpness, 1f, 3f);
bool setParams = SetTextParams(obj, text, fontSize, sharpness);
if (billboardText == null || setParams == false)
{
SafeDestroy(UIText);
SafeDestroy(billboard);
return(null);
}
if (prefab != null && prefab.transform.localScale.y < 0)
{
billboardText.YMirror = true;
}
billboardText.Scale = (1f / sharpness);
billboardText.UIText = obj;
billboardText.Direction = direction;
if (direction != null)
{
billboardText.RectTransformOverride = direction.GetComponent <RectTransform>();
}
else
{
billboardText.RectTransformOverride = null;
}
billboard.transform.localPosition = new Vector3(x, y, z);
return(billboardText);
}
/// <summary>
/// Creates a single bar game object using the chart parameters and the bar prefab
/// </summary>
/// <param name="innerPosition">the local position of the bar in the chart</param>
/// <returns>the new bar game object</returns>
private GameObject CreateBar(Vector3 innerPosition, double value, float size, float elevation, float normalizedSize, string category, string group, int index, int categoryIndex)
{
if (BarPrefabLink == null)
{
GameObject dummy = new GameObject();
dummy.AddComponent <ChartItem>();
dummy.transform.parent = transform;
return(dummy);
}
GameObject topLevel = new GameObject();
topLevel.AddComponent <ChartItem>();
topLevel.layer = gameObject.layer;
topLevel.transform.SetParent(transform, false);
topLevel.transform.localScale = new Vector3(1f, 1f, 1f);
topLevel.transform.localPosition = innerPosition;
GameObject obj = (GameObject)GameObject.Instantiate(BarPrefabLink);
Vector3 initialScale = obj.transform.localScale;
obj.transform.SetParent(topLevel.transform, false);
obj.transform.localScale = new Vector3(1f, 1f, 1f);
CharItemEffectController effect = obj.GetComponent <CharItemEffectController>();
if (effect == null)
{
effect = obj.AddComponent <CharItemEffectController>();
}
effect.WorkOnParent = true;
effect.InitialScale = false;
BarInfo inf = obj.AddComponent <BarInfo>();
obj.AddComponent <ChartItem>();
topLevel.transform.localRotation = Quaternion.identity;
obj.transform.localRotation = Quaternion.identity;
obj.transform.localPosition = Vector3.zero;
ChartCommon.HideObject(obj, hideHierarchy);
IBarGenerator generator = obj.GetComponent <IBarGenerator>();
obj.layer = gameObject.layer; // put the bar on the same layer as this object
BarObject barObj = new BarObject();
ChartCommon.HideObject(topLevel, hideHierarchy);
barObj.Bar = generator;
barObj.BarGameObject = obj;
barObj.InitialScale = initialScale;
barObj.TopObject = topLevel;
barObj.InnerPosition = innerPosition;
barObj.Size = size;
barObj.Category = category;
barObj.Group = group;
barObj.Value = value;
barObj.Elevation = elevation;
inf.BarObject = barObj;
mBars.Add(new ChartItemIndex(index, categoryIndex), barObj);
ChartItemEvents[] events = obj.GetComponentsInChildren <ChartItemEvents>();
for (int i = 0; i < events.Length; ++i)
{
if (events[i] == null)
{
continue;
}
InternalItemEvents comp = (InternalItemEvents)events[i];
comp.Parent = this;
comp.UserData = barObj;
}
ChartMaterialController[] materialController = obj.GetComponentsInChildren <ChartMaterialController>();
for (int i = 0; i < materialController.Length; i++)
{
ChartMaterialController m = materialController[i];
ChartDynamicMaterial mat = Data.GetMaterial(category);
if (mat != null)
{
m.Materials = mat;
m.Refresh();
}
}
float ySize = 1f * size * initialScale.y;
if (generator != null)
{
generator.Generate(normalizedSize, ySize);
}
SetBarSize(obj, new Vector3(BarSizeLink.Breadth * initialScale.x, ySize, BarSizeLink.Depth * initialScale.z), elevation);
if (mItemLabels != null && mItemLabels.isActiveAndEnabled)
{
string toSet = mItemLabels.TextFormat.Format(ChartAdancedSettings.Instance.FormatFractionDigits(mItemLabels.FractionDigits, value),
category, group);
Vector3 labelPos = AlignLabel(mItemLabels, innerPosition, size + elevation);
float angle = 45f;
if (mItemLabels.Alignment == ChartLabelAlignment.Base)
{
angle = -45f;
}
BillboardText billboard = ChartCommon.CreateBillboardText(null, mItemLabels.TextPrefab, topLevel.transform, toSet, labelPos.x, labelPos.y, labelPos.z, angle, obj.transform, hideHierarchy, mItemLabels.FontSize, mItemLabels.FontSharpness);
// billboard.UserData =
// billboard.UIText.fontSize = ItemLabels.FontSize;
// billboard.transform.parent =;
barObj.ItemLabel = billboard;
TextController.AddText(billboard);
}
if (mGroupLabels != null && mGroupLabels.isActiveAndEnabled)
{
if (mGroupLabels.Alignment == GroupLabelAlignment.BarBottom || mGroupLabels.Alignment == GroupLabelAlignment.BarTop || (mGroupLabels.Alignment == GroupLabelAlignment.FirstBar && index == 0))
{
Vector3 labelPos = AlignLabel(mGroupLabels, innerPosition, size + elevation);
string toSet = mGroupLabels.TextFormat.Format(group, category, group);
// float angle = 45f;
BillboardText billboard = ChartCommon.CreateBillboardText(null, mGroupLabels.TextPrefab, topLevel.transform, toSet, labelPos.x, labelPos.y, labelPos.z, 0f, obj.transform, hideHierarchy, mGroupLabels.FontSize, mGroupLabels.FontSharpness);
barObj.GroupLabel = billboard;
TextController.AddText(billboard);
}
}
if (mCategoryLabels != null && mCategoryLabels.isActiveAndEnabled)
{
if (mCategoryLabels.VisibleLabels != CategoryLabels.ChartCategoryLabelOptions.FirstOnly ||
index == 0)
{
Vector3 labelPos = AlignLabel(mCategoryLabels, innerPosition, size + elevation);
string toSet = mCategoryLabels.TextFormat.Format(category, category, group);
float angle = 45f;
if (mCategoryLabels.Alignment == ChartLabelAlignment.Base)
{
angle = -45f;
}
BillboardText billboard = ChartCommon.CreateBillboardText(null, mCategoryLabels.TextPrefab, topLevel.transform, toSet, labelPos.x, labelPos.y, labelPos.z, angle, obj.transform, hideHierarchy, mCategoryLabels.FontSize, mCategoryLabels.FontSharpness);
barObj.CategoryLabel = billboard;
TextController.AddText(billboard);
}
}
if (Orientation == ChartOrientation.Horizontal)
{
obj.transform.localRotation = Quaternion.Euler(0f, 0, -90f);
}
return(obj);
}
protected override GameObject CreateCategoryObject(Vector3[] path, int category)
{
Vector3[] newPath = new Vector3[path.Length + 1];
path.CopyTo(newPath, 0);
newPath[path.Length] = path[0];
path = newPath;
List <CanvasLines.LineSegement> seg = new List <CanvasLines.LineSegement>();
seg.Add(new CanvasLines.LineSegement(path));
RadarChartData.CategoryData cat = ((IInternalRadarData)DataSource).getCategoryData(category);
GameObject container = ChartCommon.CreateChartItem();
ChartCommon.HideObject(container, hideHierarchy);
container.transform.SetParent(transform, false);
container.transform.localScale = new Vector3(1f, 1f, 1f);
container.transform.localPosition = Vector3.zero;
container.transform.localRotation = Quaternion.identity;
if (cat.FillMaterial != null)
{
RadarFill fill = CreateFillObject(container);
fill.material = cat.FillMaterial;
fill.SetPath(path, Radius);
}
if (cat.LineMaterial != null && cat.LineThickness > 0)
{
CanvasLines lines = CreateLinesObject(container);
lines.material = cat.LineMaterial;
lines.Thickness = cat.LineThickness;
lines.SetHoverPrefab(cat.LineHover);
lines.SetLines(seg);
}
if (cat.PointMaterial != null && cat.PointSize > 0f)
{
CanvasLines points = CreateLinesObject(container);
points.material = cat.PointMaterial;
points.MakePointRender(cat.PointSize);
points.SetHoverPrefab(cat.PointHover);
points.SetLines(seg);
string name = cat.Name;
points.Hover += (int arg1, int t, object d, Vector2 arg2) => Points_Hover(name, arg1, arg2);
points.Leave += () => Points_Leave(name);
points.Click += (int arg1, int t, object d, Vector2 arg2) => Points_Click(name, arg1, arg2);
}
if (mCategoryLabels != null && mCategoryLabels.isActiveAndEnabled)
{
for (int i = 0; i < path.Length - 1; i++)
{
string group = DataSource.GetGroupName(i);
double val = DataSource.GetValue(cat.Name, group);
Vector3 labelPos = path[i];
Vector3 dir = labelPos.normalized;
labelPos += dir * mCategoryLabels.Seperation;
labelPos += new Vector3(mCategoryLabels.Location.Breadth, 0f, mCategoryLabels.Location.Depth);
int fractionDigits = 2;
if (mItemLabels != null)
{
fractionDigits = mItemLabels.FractionDigits;
}
string toSet = mCategoryLabels.TextFormat.Format(ChartAdancedSettings.Instance.FormatFractionDigits(fractionDigits, val, CustomNumberFormat), cat.Name, group);
BillboardText billboard = ChartCommon.CreateBillboardText(null, mCategoryLabels.TextPrefab, transform, toSet, labelPos.x, labelPos.y, labelPos.z, 0f, null, hideHierarchy, mCategoryLabels.FontSize, mCategoryLabels.FontSharpness);
TextController.AddText(billboard);
AddBillboardText(cat.Name, billboard);
}
}
return(container);
}
internal static BillboardText CreateBillboardText(BillboardText item, Text prefab, Transform parentTransform, string text, float x, float y, float z, float angle, Transform relativeFrom, bool hideHirarechy, int fontSize, float sharpness)
{
if (item != null)
{
return(UpdateBillboardText(item, parentTransform, text, x, y, z, angle, relativeFrom, hideHirarechy));
}
if (prefab == null || prefab.gameObject == null)
{
GameObject g = Resources.Load("Chart And Graph/DefaultText") as GameObject;
prefab = g.GetComponent <Text>();
}
GameObject UIText = (GameObject)GameObject.Instantiate(prefab.gameObject);
GameObject billboard = new GameObject();
ChartCommon.HideObject(billboard, hideHirarechy);
if (parentTransform != null)
{
billboard.transform.SetParent(parentTransform, false);
UIText.transform.SetParent(parentTransform, false);
}
BillboardText billboardText = billboard.AddComponent <BillboardText>();
billboard.AddComponent <ChartItem>();
TextDirection direction = UIText.GetComponent <TextDirection>();
Text TextObj = UIText.GetComponent <Text>();
if (direction != null)
{
TextObj = direction.Text;
if (relativeFrom != null)
{
direction.SetRelativeTo(relativeFrom, billboard.transform);
}
else
{
direction.SetDirection(angle);
}
}
if (billboardText == null || TextObj == null)
{
SafeDestroy(UIText);
SafeDestroy(billboard);
return(null);
}
sharpness = Mathf.Clamp(sharpness, 1f, 3f);
TextObj.fontSize = (int)(fontSize * sharpness);
TextObj.horizontalOverflow = HorizontalWrapMode.Overflow;
TextObj.verticalOverflow = VerticalWrapMode.Overflow;
TextObj.resizeTextForBestFit = false;
billboardText.Scale = 1f / sharpness;
TextObj.text = text;
billboardText.UIText = TextObj;
billboardText.Direction = direction;
if (direction != null)
{
billboardText.RectTransformOverride = direction.GetComponent <RectTransform>();
}
else
{
billboardText.RectTransformOverride = null;
}
billboard.transform.localPosition = new Vector3(x, y, z);
return(billboardText);
}
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);
}
}
private void GeneratePie(bool update)
{
if (mFixPositionPie == null)
{
update = false;
}
if (update == false)
{
ClearChart();
}
else
{
EnsureTextController();
}
if (((IInternalPieData)Data).InternalDataSource == null)
{
return;
}
double[,] data = ((IInternalPieData)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;
}
float start = startAngle;
if (clockWise)
{
start -= angleSpan;
}
float totalGaps = columnCount * spacingAngle;
float spanWithoutGaps = angleSpan - totalGaps;
if (spanWithoutGaps < 0f)
{
spanWithoutGaps = 0f;
}
if (mFixPositionPie == null)
{
mFixPositionPie = new GameObject("FixPositionPie", typeof(ChartItem));
ChartCommon.HideObject(mFixPositionPie, hideHierarchy);
mFixPositionPie.transform.SetParent(transform, false);
if (IsCanvas)
{
var rectTrans = mFixPositionPie.AddComponent <RectTransform>();
rectTrans.anchorMax = new Vector2(0.5f, 0.5f);
rectTrans.anchorMin = new Vector2(0.5f, 0.5f);
rectTrans.pivot = new Vector2(0.5f, 0.5f);
rectTrans.anchoredPosition = new Vector2(0.5f, 0.5f);
}
}
for (int i = 0; i < columnCount; ++i)
{
object userData = ((IInternalPieData)Data).InternalDataSource.Columns[i].UserData;
float radiusScale = 1f;
float depthScale = 1f;
float depthOffset = 0f;
if (userData != null && userData is PieData.CategoryData)
{
radiusScale = ((PieData.CategoryData)userData).RadiusScale;
depthScale = ((PieData.CategoryData)userData).DepthScale;
depthOffset = ((PieData.CategoryData)userData).DepthOffset;
}
if (radiusScale <= 0.001f)
{
radiusScale = 1f;
}
if (depthScale <= 0.001f)
{
depthScale = 1f;
}
string name = ((IInternalPieData)Data).InternalDataSource.Columns[i].Name;
double amount = Math.Max(data[0, i], 0);
if (amount == 0f)
{
continue;
}
float weight = (float)(amount / total);
float currentSpan = spanWithoutGaps * weight;
GameObject pieObject = null;
IPieGenerator generator = null;
PieObject dataObject;
CanvasLines.LineSegement line;
float modifiedRadius = Mathf.Max(radius * radiusScale, torusRadius);
// float modifiedDepth = d
float lineAngle = start + currentSpan * 0.5f;
if (mPies.TryGetValue(name, out dataObject))
{
dataObject.StartAngle = start;
dataObject.AngleSpan = currentSpan;
generator = dataObject.Generator;
if (dataObject.ItemLabel)
{
Vector3 labelPos = AlignTextPosition(mItemLabels, dataObject, out line, modifiedRadius);
dataObject.ItemLabel.transform.localPosition = labelPos;
string toSet = ChartAdancedSettings.Instance.FormatFractionDigits(mItemLabels.FractionDigits, amount, CustomNumberFormat);
toSet = mItemLabels.TextFormat.Format(toSet, name, "");
ChartCommon.UpdateTextParams(dataObject.ItemLabel.UIText, toSet);
if (dataObject.ItemLine != null)
{
var lst = new List <CanvasLines.LineSegement>();
lst.Add(line);
dataObject.ItemLine.SetLines(lst);
}
}
if (dataObject.CategoryLabel != null)
{
Vector3 labelPos = AlignTextPosition(mCategoryLabels, dataObject, out line, modifiedRadius);
dataObject.CategoryLabel.transform.localPosition = labelPos;
if (dataObject.CategoryLine != null)
{
var lst = new List <CanvasLines.LineSegement>();
lst.Add(line);
dataObject.CategoryLine.SetLines(lst);
}
}
Vector2 add = ChartCommon.FromPolar(start + currentSpan * 0.5f, Extrusion);
dataObject.TopObject.transform.localPosition = new Vector3(add.x, add.y, 0f);
}
else
{
GameObject topObject = new GameObject();
if (IsCanvas)
{
topObject.AddComponent <RectTransform>();
}
ChartCommon.HideObject(topObject, hideHierarchy);
topObject.AddComponent <ChartItem>();
topObject.transform.SetParent(mFixPositionPie.transform);
topObject.transform.localPosition = new Vector3();
topObject.transform.localRotation = Quaternion.identity;
topObject.transform.localScale = new Vector3(1f, 1f, 1f);
generator = PreparePieObject(out pieObject);
ChartCommon.EnsureComponent <ChartItem>(pieObject);
ChartMaterialController control = ChartCommon.EnsureComponent <ChartMaterialController>(pieObject);
control.Materials = Data.GetMaterial(name);
control.Refresh();
dataObject = new PieObject();
dataObject.StartAngle = start;
dataObject.AngleSpan = currentSpan;
dataObject.TopObject = topObject;
dataObject.Generator = generator;
dataObject.category = name;
var pieInfo = pieObject.AddComponent <PieInfo>();
pieInfo.pieObject = dataObject;
pieObject.transform.SetParent(topObject.transform);
Vector2 add = ChartCommon.FromPolar(start + currentSpan * 0.5f, Extrusion);
pieObject.transform.localPosition = new Vector3(0f, 0f, 0f);
pieObject.transform.localScale = new Vector3(1f, 1f, 1f);
pieObject.transform.localRotation = Quaternion.identity;
mPies.Add(name, dataObject);
topObject.transform.localPosition = new Vector3(add.x, add.y, 0f);
CharItemEffectController effect = ChartCommon.EnsureComponent <CharItemEffectController>(pieObject);
effect.WorkOnParent = true;
effect.InitialScale = false;
ChartItemEvents[] events = pieObject.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, out line, modifiedRadius);
if (line != null && IsUnderCanvas)
{
dataObject.ItemLine = AddLineRenderer(topObject, line);
}
string toSet = ChartAdancedSettings.Instance.FormatFractionDigits(mItemLabels.FractionDigits, amount, CustomNumberFormat);
toSet = mItemLabels.TextFormat.Format(toSet, name, "");
BillboardText billboard = ChartCommon.CreateBillboardText(null, mItemLabels.TextPrefab, topObject.transform, toSet, labelPos.x, labelPos.y, labelPos.z, lineAngle, topObject.transform, hideHierarchy, mItemLabels.FontSize, mItemLabels.FontSharpness);
dataObject.ItemLabel = billboard;
TextController.AddText(billboard);
}
if (mCategoryLabels != null)
{
Vector3 labelPos = AlignTextPosition(mCategoryLabels, dataObject, out line, modifiedRadius);
if (line != null && IsUnderCanvas)
{
dataObject.CategoryLine = AddLineRenderer(topObject, line);
}
string toSet = name;
toSet = mCategoryLabels.TextFormat.Format(toSet, "", "");
BillboardText billboard = ChartCommon.CreateBillboardText(null, mCategoryLabels.TextPrefab, topObject.transform, toSet, labelPos.x, labelPos.y, labelPos.z, lineAngle, topObject.transform, hideHierarchy, mCategoryLabels.FontSize, mCategoryLabels.FontSharpness);
dataObject.CategoryLabel = billboard;
TextController.AddText(billboard);
}
}
float maxDepth = Mathf.Max(OuterDepthLink, InnerDepthLink);
float depthSize = maxDepth * depthScale;
if (pieObject != null)
{
float depthStart = (maxDepth - depthSize) * 0.5f;
pieObject.transform.localPosition = new Vector3(0f, 0f, depthStart - depthSize * depthOffset);
}
dataObject.Value = (float)data[0, i];
generator.Generate(Mathf.Deg2Rad * start, Mathf.Deg2Rad * currentSpan, modifiedRadius, torusRadius, meshSegements, OuterDepthLink * depthScale, InnerDepthLink * depthScale);
start += spacingAngle + currentSpan;
}
}
