Example #1
0
        /// <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);
        }
Example #3
0
        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);
        }
Example #4
0
        /// <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);
 }
Example #6
0
 partial void InnerSetAxis(double scrollOffset, AnyChart parent, AxisBase axis, ChartOrientation axisOrientation, bool isSubDivisions);
Example #7
0
 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();
        }
Example #9
0
        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();
        }