graph chart引入&骑行结果弹窗

Assets/Chart And Graph/InBeta/PyramidChart/PyramidCanvasGenerator.cs

@@ -0,0 +1,202 @@
+#define Graph_And_Chart_PRO
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace ChartAndGraph
+{
+    [Serializable]
+    public class PyramidCanvasGenerator : MaskableGraphic, IPyramidGenerator
+    {
+
+        public RectTransform Container;
+        public Text Title;
+        public Text Info;
+        public Image Sprite;
+
+        bool mPopulated = false;
+        float mBaseX1;
+        float mBaseX2;
+        float mBaseSize;
+        float mSlopLeft;
+        float mSlopeRight;
+        float mHeight;
+        float mInset;
+        float mStartV;
+        float mEndV;
+        CanvasGroup mGroup;
+        UIVertex[] vertices = new UIVertex[4];
+        Vector2[] normals = new Vector2[4];
+
+        protected override void Start()
+        {
+            base.Start();
+            mGroup = ChartCommon.EnsureComponent<CanvasGroup>(gameObject); 
+
+        }
+
+        public GameObject ContainerObject {
+            get {
+                if (Container == null)
+                    return null;
+                return Container.gameObject;
+            }
+        }
+
+        public void SetAlpha(float alpha)
+        {
+            if(mGroup != null)
+                mGroup.alpha = alpha;
+        }
+        public override Texture mainTexture
+        {
+            get { return material.mainTexture; }
+        }
+        public void ApplyInfo(string title, string text, Sprite image,float scale)
+        {
+            if(Container != null)
+            {
+                Vector3 centtroid = vertices[0].position + vertices[1].position + vertices[2].position + vertices[3].position;
+                centtroid *= 0.25f;
+                float upperSize = Math.Abs(vertices[2].position.x - vertices[3].position.x);
+                float downSize = Math.Abs(vertices[0].position.x - vertices[1].position.x);
+                float total = upperSize + downSize;
+                float weight = (downSize - upperSize) / total;
+                weight = -weight * 0.5f + 0.5f;
+                weight = Mathf.Lerp(0.3f, 0.7f, weight);
+                centtroid.y = Mathf.Lerp(vertices[0].position.y, vertices[2].position.y, weight);
+                centtroid = new Vector3(centtroid.x / rectTransform.rect.width, centtroid.y / rectTransform.rect.height);
+                centtroid += new Vector3(0.5f, 0.5f, 0f);
+                Container.anchorMax = centtroid;
+                Container.anchorMin = centtroid;
+                Container.anchoredPosition = new Vector2();
+                Container.sizeDelta = new Vector2(Mathf.Abs(mBaseX1 - mBaseX2) - mInset*4, mHeight - mInset*2);
+                Container.localScale = new Vector3(scale, scale, scale);
+            }
+            if (Title != null)
+                Title.text = title;
+            if (Info != null)
+                Info.text = text;
+            if (Sprite != null)
+                Sprite.sprite = image;
+        }
+
+        public void Generate()
+        {
+            SetAllDirty();
+            Rebuild(CanvasUpdate.PreRender);
+        }
+
+        public Vector3 GetTextPosition(PyramidChart.JustificationType justification, bool isBase)
+        {
+            Vector3 res = new Vector3();
+            switch(justification)
+            {
+                case PyramidChart.JustificationType.LeftAligned:
+                    if (isBase)
+                        res = vertices[0].position;
+                    else
+                        res = (vertices[0].position + vertices[2].position) * 0.5f;
+                    break;
+                case PyramidChart.JustificationType.RightAligned:
+                    if (isBase)
+                        res = vertices[1].position;
+                    else
+                        res = (vertices[1].position + vertices[3].position) * 0.5f;
+                    break;
+                case PyramidChart.JustificationType.CenterAligned:
+                    if (isBase)
+                        res = (vertices[0].position + vertices[1].position) * 0.5f;
+                    else
+                        res = (vertices[0].position + vertices[1].position +vertices[2].position + vertices[3].position) * 0.25f;
+                    break;
+
+            }
+            return res;
+        }
+
+        public void GetUpperBase(out float baseX1, out float baseX2)
+        {
+            baseX1 = vertices[2].position.x + mBaseSize * 0.5f;
+            baseX2 = vertices[3].position.x + mBaseSize * 0.5f;
+        }
+
+        public void SetParams(float baseX1, float baseX2, float baseSize, float slopLeft, float slopeRight, float height, float inset, float startV, float endV)
+        {
+            mPopulated = true; 
+            mBaseX1 = baseX1;
+            mBaseX2 = baseX2;
+            mBaseSize = baseSize;
+            mSlopLeft = slopLeft;
+            mSlopeRight = slopeRight;
+            mHeight = height;
+            mInset = inset;
+            mStartV = startV;
+            mEndV = endV;
+            PyramidMesh.Generate2dMesh(vertices, normals, mBaseX1, mBaseX2, mBaseSize, mSlopLeft, mSlopeRight, mHeight,mStartV,mEndV);
+        }
+
+#pragma warning disable 0672
+
+        protected override void OnFillVBO(List<UIVertex> vbo)
+        {
+            vbo.Clear();
+            if (mPopulated == false)
+                return;
+            CanvasChartMesh mesh = new CanvasChartMesh(vbo);
+            FillChartMesh(mesh);
+        }
+
+#pragma warning restore 0672
+
+#if (!UNITY_5_2_0) && (!UNITY_5_2_1)
+        protected override void OnPopulateMesh(VertexHelper vh)
+        {
+            vh.Clear();
+            if (mPopulated == false)
+                return;
+            CanvasChartMesh mesh = new CanvasChartMesh(vh);
+            FillChartMesh(mesh);
+        }
+#endif
+#pragma warning disable 0672
+#if !UNITY_2017_1_OR_NEWER
+        protected override void OnPopulateMesh(Mesh m)
+        {
+            m.Clear();
+            if (mPopulated == false)
+                return;
+            WorldSpaceChartMesh chartmesh = new WorldSpaceChartMesh(true);
+            FillChartMesh(chartmesh);
+            chartmesh.ApplyToMesh(m);
+        }
+#endif
+#pragma warning restore 0672
+
+        void FillChartMesh(IChartMesh mesh)
+        {
+            UIVertex v1 = vertices[0];
+            UIVertex v2 = vertices[1];
+            UIVertex v3 = vertices[2];
+            UIVertex v4 = vertices[3];
+
+            v1.position += (Vector3)(normals[0] * mInset);
+            v2.position += (Vector3)(normals[1] * mInset);
+            v3.position += (Vector3)(normals[2] * mInset);
+            v4.position += (Vector3)(normals[3] * mInset);
+
+            Vector2 inter;
+            if(ChartCommon.SegmentIntersection(v1.position,v3.position,v2.position,v4.position,out inter))
+            {
+                v3.position = inter;
+                v4.position = inter;
+            }
+
+            mesh.AddQuad(v1, v2, v3, v4);
+        }
+
+    }
+}