/// <summary>
/// used internally , adds the axis main divisions to the chart mesh
/// </summary>
/// <param name="parent"></param>
/// <param name="parentTransform"></param>
/// <param name="mesh"></param>
/// <param name="orientation"></param>
internal void AddMainDivisionToChartMesh(double scrollOffset, AnyChart parent, Transform parentTransform, IChartMesh mesh, ChartOrientation orientation)
{
double maxValue = ((IInternalUse)parent).InternalMaxValue(this);
double minValue = ((IInternalUse)parent).InternalMinValue(this);
double range = maxValue - minValue;
double?gap = GetMainGap(parent, range);
if (gap.HasValue == false)
{
return;
}
mesh.Tile = ChartCommon.GetTiling(MainDivisions.MaterialTiling);
if ((MainDivisions.Alignment & ChartDivisionAligment.Opposite) == ChartDivisionAligment.Opposite)
{
DrawDivisions(scrollOffset, parent, parentTransform, MainDivisions, mesh, 0, orientation, gap.Value, false, -1);
}
if ((MainDivisions.Alignment & ChartDivisionAligment.Standard) == ChartDivisionAligment.Standard)
{
DrawDivisions(scrollOffset, parent, parentTransform, MainDivisions, mesh, 0, orientation, gap.Value, true, -1);
}
}
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);
}
private void DrawDivisions(double scrollOffset, AnyChart parent, Transform parentTransform, ChartDivisionInfo info, IChartMesh mesh, int group, ChartOrientation orientation, double gap, bool oppositeSide, double mainGap)
{
//scrollOffset = -scrollOffset;
double parentSize = (orientation == ChartOrientation.Vertical) ? ((IInternalUse)parent).InternalTotalHeight : ((IInternalUse)parent).InternalTotalWidth;
DoubleVector3 startPosition, lengthDirection, advanceDirection;
GetDirectionVectors(parent, info, orientation, 0f, oppositeSide, out startPosition, out lengthDirection, out advanceDirection);
double markDepth = ChartCommon.GetAutoDepth(parent, orientation, info);
double length = ChartCommon.GetAutoLength(parent, orientation, info);
double backLength = (orientation == ChartOrientation.Vertical) ? ((IInternalUse)parent).InternalTotalWidth : ((IInternalUse)parent).InternalTotalHeight;
if (info.MarkBackLength.Automatic == false)
{
backLength = info.MarkBackLength.Value;
}
double totaluv = Math.Abs(length);
if (backLength != 0 && markDepth > 0)
{
totaluv += Math.Abs(backLength) + Math.Abs(markDepth);
}
DoubleVector3 halfThickness = advanceDirection * (info.MarkThickness * 0.5f);
// if (scrollOffset != 0f)
// last--;
bool hasValues = ((IInternalUse)parent).InternalHasValues(this);
double maxValue = ((IInternalUse)parent).InternalMaxValue(this);
double minValue = ((IInternalUse)parent).InternalMinValue(this);
double range = maxValue - minValue;
float AutoAxisDepth = Depth.Value;
// float scrollFactor = (scrollOffset / (float)(maxValue - minValue));
//scrollOffset = scrollFactor * parentSize;
if (Depth.Automatic)
{
AutoAxisDepth = (float)((((IInternalUse)parent).InternalTotalDepth) - markDepth);
}
double startValue = (scrollOffset + minValue);
double endValue = (scrollOffset + maxValue) + double.Epsilon;
double direction = 1.0;
Func <double, double> ValueToPosition = x => ((x - startValue) / range) * parentSize;
if (startValue > endValue)
{
direction = -1.0;
//ValueToPosition = x => (1.0- ((x - startValue) / range)) * parentSize;
}
gap = Math.Abs(gap);
double fraction = gap - (scrollOffset - Math.Floor((scrollOffset / gap) - double.Epsilon) * gap);
double mainfraction = -1f;
double currentMain = 0f;
if (mainGap > 0f)
{
mainfraction = mainGap - (scrollOffset - Math.Floor((scrollOffset / mainGap) - double.Epsilon) * mainGap);
currentMain = (scrollOffset + minValue + mainfraction);
}
int i = 0;
mTmpToRemove.Clear();
double startRange = startValue + fraction;
foreach (double key in mFormats.Keys)
{
if (key * direction > endValue * direction || key * direction < startRange * direction)
{
mTmpToRemove.Add(key);
}
}
for (int k = 0; k < mTmpToRemove.Count; k++)
{
mFormats.Remove(mTmpToRemove[k]);
}
for (double current = startRange; direction *current <= direction *endValue; current += gap * direction)
{
++i;
if (i > 3000)
{
break;
}
if (mainGap > 0.0)
{
if (Math.Abs(current - currentMain) < 0.00001)
{
currentMain += mainGap;
continue;
}
if (current > currentMain)
{
currentMain += mainGap;
}
}
double offset = ValueToPosition(current);
if (offset < 0 || offset > parentSize)
{
continue;
}
DoubleVector3 start = startPosition + advanceDirection * offset;
DoubleVector3 size = halfThickness + length * lengthDirection;
start -= halfThickness;
//size += halfThickness;
float uvoffset = 0f;
Rect r = ChartCommon.FixRect(new Rect((float)start.x, (float)start.y, (float)size.x, (float)size.y));
SetMeshUv(mesh, (float)(-length / totaluv), uvoffset);
uvoffset += Math.Abs(mesh.Length);
mesh.AddXYRect(r, group, AutoAxisDepth);
if (hasValues)
{
double val = Math.Round(current * 1000.0) / 1000.0;
string toSet = "";
double keyVal = val;// (int)Math.Round(val);
var dic = (orientation == ChartOrientation.Horizontal) ? parent.HorizontalValueToStringMap : parent.VerticalValueToStringMap;
if (!(Math.Abs(val - keyVal) < 0.001 && dic.TryGetValue(keyVal, out toSet)))
{
if (mFormats.TryGetValue(val, out toSet) == false)
{
if (format == AxisFormat.Number)
{
toSet = ChartAdancedSettings.Instance.FormatFractionDigits(info.FractionDigits, val, parent.CustomNumberFormat);
}
else
{
DateTime date = ChartDateUtility.ValueToDate(val);
if (format == AxisFormat.DateTime)
{
toSet = ChartDateUtility.DateToDateTimeString(date, parent.CustomDateTimeFormat);
}
else
{
if (format == AxisFormat.Date)
{
toSet = ChartDateUtility.DateToDateString(date);
}
else
{
toSet = ChartDateUtility.DateToTimeString(date);
}
}
}
toSet = info.TextPrefix + toSet + info.TextSuffix;
mFormats[val] = toSet;
}
}
else
{
toSet = info.TextPrefix + toSet + info.TextSuffix;
}
DoubleVector3 textPos = new DoubleVector3(start.x, start.y);
textPos += lengthDirection * info.TextSeperation;
TextData userData = new TextData();
userData.interp = (float)(offset / parentSize);
userData.info = info;
userData.fractionDigits = info.FractionDigits;
mesh.AddText(parent, info.TextPrefab, parentTransform, info.FontSize, info.FontSharpness, toSet, (float)textPos.x, (float)textPos.y, AutoAxisDepth + info.TextDepth, 0f, userData);
}
if (markDepth > 0)
{
if (orientation == ChartOrientation.Horizontal)
{
SetMeshUv(mesh, (float)(markDepth / totaluv), uvoffset);
r = ChartCommon.FixRect(new Rect((float)start.x, AutoAxisDepth, (float)size.x, (float)markDepth));
mesh.AddXZRect(r, group, (float)start.y);
}
else
{
SetMeshUv(mesh, (float)(-markDepth / totaluv), uvoffset);
r = ChartCommon.FixRect(new Rect((float)start.y, AutoAxisDepth, (float)size.y, (float)markDepth));
mesh.AddYZRect(r, group, (float)start.x);
}
uvoffset += Math.Abs(mesh.Length);
if (backLength != 0)
{
SetMeshUv(mesh, (float)(backLength / totaluv), uvoffset);
uvoffset += Math.Abs(mesh.Length);
DoubleVector3 backSize = halfThickness + backLength * lengthDirection;
Rect backR = ChartCommon.FixRect(new Rect((float)start.x, (float)start.y, (float)backSize.x, (float)backSize.y));
mesh.AddXYRect(backR, group, (float)(AutoAxisDepth + markDepth));
}
}
}
// Debug.Log("start");
// Debug.Log(mFormats.Count);
// Debug.Log(cached);
}
/// <summary>
/// used internally , adds the axis sub divisions to the chart mesh
/// </summary>
/// <param name="parent"></param>
/// <param name="parentTransform"></param>
/// <param name="mesh"></param>
/// <param name="orientation"></param>
internal void AddSubdivisionToChartMesh(double scrollOffset, AnyChart parent, Transform parentTransform, IChartMesh mesh, ChartOrientation orientation)
{
int total = SubDivisions.Total;
if (total <= 1) // no need for more
{
return;
}
double maxValue = ((IInternalUse)parent).InternalMaxValue(this);
double minValue = ((IInternalUse)parent).InternalMinValue(this);
double range = maxValue - minValue;
double?gap = GetMainGap(parent, range);
if (gap.HasValue == false)
{
return;
}
double subGap = gap.Value / (total);
mesh.Tile = ChartCommon.GetTiling(SubDivisions.MaterialTiling);
if ((SubDivisions.Alignment & ChartDivisionAligment.Opposite) == ChartDivisionAligment.Opposite)
{
DrawDivisions(scrollOffset, parent, parentTransform, SubDivisions, mesh, 0, orientation, subGap, false, gap.Value);
}
if ((SubDivisions.Alignment & ChartDivisionAligment.Standard) == ChartDivisionAligment.Standard)
{
DrawDivisions(scrollOffset, parent, parentTransform, SubDivisions, mesh, 0, orientation, subGap, true, gap.Value);
}
}
internal static float GetAutoLength(AnyChart parent, ChartOrientation orientation)
{
return((orientation == ChartOrientation.Vertical) ? ((IInternalUse)parent).InternalTotalWidth : ((IInternalUse)parent).InternalTotalHeight);
}
partial void InnerSetAxis(double scrollOffset, AnyChart parent, AxisBase axis, ChartOrientation axisOrientation, bool isSubDivisions);
public void SetAxis(double scrollOffset, AnyChart parent, AxisBase axis, ChartOrientation axisOrientation, bool isSubDivisions)
{
InnerSetAxis(scrollOffset, parent, axis, axisOrientation, isSubDivisions);
}
/// <summary>
/// sets the axis settings. Calling this method will cause the axisgenerator to create the axis mesh
/// </summary>
/// <param name="parent"></param>
/// <param name="axis"></param>
/// <param name="axisOrientation"></param>
/// <param name="isSubDivisions"></param>
partial void InnerSetAxis(double scrollOffset, AnyChart parent, AxisBase axis, ChartOrientation axisOrientation, bool isSubDivisions)
{
mScroll = scrollOffset;
mParent = parent;
mAxis = axis;
mOrientation = axisOrientation;
mIsSubDivision = isSubDivisions;
if (mMesh == null)
{
mMesh = new WorldSpaceChartMesh(2);
mMesh.RecycleText = true;
}
mMesh.Clear();
mMesh.Orientation = axisOrientation;
mAxis = axis;
if (isSubDivisions)
{
axis.AddSubdivisionToChartMesh(scrollOffset, parent, transform, mMesh, axisOrientation);
}
else
{
axis.AddMainDivisionToChartMesh(scrollOffset, parent, transform, mMesh, axisOrientation);
}
if (mMesh.TextObjects != null)
{
foreach (BillboardText text in mMesh.TextObjects)
{
((IInternalUse)parent).InternalTextController.AddText(text);
}
}
mTexts = mMesh.CurrentTextObjects;
Mesh newMesh = mMesh.Generate(mCreated);
mCreated = newMesh;
newMesh.hideFlags = HideFlags.DontSave;
if (mFilter == null)
{
mFilter = GetComponent <MeshFilter>();
}
mFilter.sharedMesh = newMesh;
MeshCollider collider = GetComponent <MeshCollider>();
if (collider != null)
{
collider.sharedMesh = newMesh;
}
ChartCommon.CleanMesh(newMesh, ref mCleanMesh);
MeshRenderer renderer = GetComponent <MeshRenderer>();
if (renderer != null)
{
Material m = mAxis.MainDivisions.Material;
float tiling = GetTiling(parent, axisOrientation, mAxis.MainDivisions);
if (isSubDivisions)
{
m = mAxis.SubDivisions.Material;
tiling = GetTiling(parent, axisOrientation, mAxis.SubDivisions);
}
mMaterial = m;
if (m != null)
{
ChartCommon.SafeDestroy(mDispose);
mDispose = new Material(m);
mDispose.hideFlags = HideFlags.DontSave;
renderer.sharedMaterial = mDispose;
mTiling = tiling;
if (mDispose.HasProperty("_ChartTiling"))
{
mDispose.SetFloat("_ChartTiling", mTiling);
}
}
}
mMesh.DestoryRecycled();
}
public void SetAxis(double scrollOffset, AnyChart parent, AxisBase axis, ChartOrientation axisOrientation, bool isSubDivisions)
{
mScrollOffset = scrollOffset;
raycastTarget = false;
color = Color.white;
mAxis = axis;
mParent = parent;
mIsSubDivisions = isSubDivisions;
mOrientation = axisOrientation;
if (mMesh == null)
{
mMesh = new CanvasChartMesh(true);
mMesh.RecycleText = true;
}
mMesh.Clear();
if (isSubDivisions)
{
mAxis.AddMainDivisionToChartMesh(mScrollOffset, mParent, transform, mMesh, mOrientation);
}
else
{
mAxis.AddSubdivisionToChartMesh(mScrollOffset, mParent, transform, mMesh, mOrientation);
}
mTexts = mMesh.CurrentTextObjects;
if (mMesh.TextObjects != null)
{
foreach (BillboardText text in mMesh.TextObjects)
{
((IInternalUse)parent).InternalTextController.AddText(text);
}
}
canvasRenderer.materialCount = 1;
if (mDispose != null)
{
ChartCommon.SafeDestroy(mDispose);
}
float tiling = 1f;
if (!isSubDivisions)
{
if (axis.SubDivisions.Material != null)
{
mMaterial = axis.SubDivisions.Material;
mDispose = new Material(mMaterial);
mDispose.hideFlags = HideFlags.DontSave;
material = mDispose;
tiling = GetTiling(axis.SubDivisions.MaterialTiling);
}
}
else
{
if (axis.MainDivisions.Material != null)
{
mMaterial = axis.MainDivisions.Material;
mDispose = new Material(mMaterial);
mDispose.hideFlags = HideFlags.DontSave;
material = mDispose;
tiling = GetTiling(axis.MainDivisions.MaterialTiling);
}
}
mTiling = tiling;
if (mDispose != null)
{
if (mDispose.HasProperty("_ChartTiling"))
{
mDispose.SetFloat("_ChartTiling", tiling);
}
}
SetAllDirty();
Rebuild(CanvasUpdate.PreRender);
mMesh.DestoryRecycled();
}
