graph chart引入&骑行结果弹窗

Assets/Chart And Graph/Script/Common/ChartItem.cs

@@ -0,0 +1,17 @@
+#define Graph_And_Chart_PRO
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+
+namespace ChartAndGraph
+{
+    /// <summary>
+    /// marks an objects as a chart item. chart items are managed by the chart implementation. this should not be used under normal cirtcumstance
+    /// </summary>
+    public class ChartItem : MonoBehaviour
+    {
+        public object TagData { get; set; }
+    }
+}

Assets/Chart And Graph/Script/Common/ChartItem.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 55b5a59897c650342a9b23ff348a9992
+timeCreated: 1480803143
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Chart And Graph/Script/Common/ChartItemIndex.cs

@@ -0,0 +1,38 @@
+#define Graph_And_Chart_PRO
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ChartAndGraph.Common
+{
+    /// <summary>
+    /// and index of a chart item. this include group and category data.
+    /// </summary>
+    struct ChartItemIndex
+    {
+        public ChartItemIndex(int group,int category) : this()
+        {
+            Group = group;
+            Category = category;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is ChartItemIndex)
+            {
+                ChartItemIndex index = (ChartItemIndex)obj;
+                if (index.Group == Group && index.Category == Category)
+                    return true;
+            }
+            return false;
+        }
+
+        public override int GetHashCode()
+        {
+            return Group.GetHashCode() ^ Category.GetHashCode();
+        }
+        public int Group { get; set; }
+        public int Category { get; set; }
+    }
+}

Assets/Chart And Graph/Script/Common/ChartItemIndex.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5cf2efc2c6b3fe64cb0699e90a7aaa0a
+timeCreated: 1478103020
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Chart And Graph/Script/Common/ChartItemNoDelete.cs

@@ -0,0 +1,12 @@
+#define Graph_And_Chart_PRO
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ChartAndGraph
+{
+    class ChartItemNoDelete : ChartItem
+    {
+    }
+}

Assets/Chart And Graph/Script/Common/ChartItemNoDelete.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6a6adcbcd84308345821c54ba775f7a2
+timeCreated: 1536613512
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Chart And Graph/Script/Common/DoubleRect.cs

@@ -0,0 +1,29 @@
+#define Graph_And_Chart_PRO
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ChartAndGraph
+{
+    public struct DoubleRect
+    {
+        public double X,Y,Width,Height;
+
+        public DoubleRect(double x,double y,double width,double height)
+        {
+            X = x;
+            Y = y;
+            Width = width;
+            Height = height;
+        }
+
+        public override string ToString()
+        {
+            return string.Format("x:{0},y:{1},w:{2},h:{3}", X, Y, Width, Height);
+        }
+
+        public DoubleVector3 min { get { return new DoubleVector3(X, Y); } }
+        public DoubleVector3 max { get { return new DoubleVector3(X + Width, Y + Height); } }
+    }
+}

Assets/Chart And Graph/Script/Common/DoubleRect.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 881be2c9634d9fe4fbbd9a22229cbfed
+timeCreated: 1505755331
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Chart And Graph/Script/Common/DoubleVector2.cs

@@ -0,0 +1,33 @@
+#define Graph_And_Chart_PRO
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+
+namespace ChartAndGraph
+{
+    [Serializable    ]
+    public struct DoubleVector2
+    {
+        public double x, y;
+        public DoubleVector2(Vector2 v)
+        {
+            x = v.x;
+            y = v.y;
+        }
+        public Vector2 ToVector2()
+        {
+            return new Vector2((float)x, (float)y);
+        }
+        public DoubleVector3 ToDoubleVector3()
+        {
+            return new DoubleVector3(x, y);
+        }
+        public DoubleVector2(double _x, double _y)
+        {
+            x = _x;
+            y = _y;
+        }
+    }
+}

Assets/Chart And Graph/Script/Common/DoubleVector2.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e244625ec1140054eaf6270afce62593
+timeCreated: 1500148138
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Chart And Graph/Script/Common/DoubleVector3.cs

@@ -0,0 +1,406 @@
+#define Graph_And_Chart_PRO
+using System;
+using System.Runtime.CompilerServices;
+using UnityEngine;
+using UnityEngine.Internal;
+using UnityEngine.Scripting;
+
+namespace ChartAndGraph
+{
+    public struct DoubleVector3
+    { 
+        public double x;
+
+        public double y;
+
+        public double z;
+
+        public double this[int index]
+        {
+            get
+            {
+                double result;
+                switch (index)
+                {
+                    case 0:
+                        result = this.x;
+                        break;
+                    case 1:
+                        result = this.y;
+                        break;
+                    case 2:
+                        result = this.z;
+                        break;
+                    default:
+                        throw new IndexOutOfRangeException("Invalid DoubleVector3 index!");
+                }
+                return result;
+            }
+            set
+            {
+                switch (index)
+                {
+                    case 0:
+                        this.x = value;
+                        break;
+                    case 1:
+                        this.y = value;
+                        break;
+                    case 2:
+                        this.z = value;
+                        break;
+                    default:
+                        throw new IndexOutOfRangeException("Invalid DoubleVector3 index!");
+                }
+            }
+        }
+        public Vector2 ToVector2()
+        {
+            return new Vector2((float)x, (float)y);
+        }
+
+        public Vector3 ToVector3()
+        {
+            return new Vector3((float)x, (float)y, (float)z);
+        }
+        public Vector3 ToVector4()
+        {
+            return new Vector4((float)x, (float)y, (float)z,0f);
+        }
+        public DoubleVector4 ToDoubleVector4()
+        {
+            return new DoubleVector4(x, y, z, 0.0);
+        }
+        public DoubleVector2 ToDoubleVector2()
+        {
+            return new DoubleVector2(x, y);
+        }
+        public DoubleVector3 normalized
+        {
+            get
+            {
+                return DoubleVector3.Normalize(this);
+            }
+        }
+
+        public double magnitude
+        {
+            get
+            {
+                return Math.Sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+            }
+        }
+
+        public double sqrMagnitude
+        {
+            get
+            {
+                return this.x * this.x + this.y * this.y + this.z * this.z;
+            }
+        }
+
+        public static DoubleVector3 zero
+        {
+            get
+            {
+                return new DoubleVector3(0f, 0f, 0f);
+            }
+        }
+
+        public static DoubleVector3 one
+        {
+            get
+            {
+                return new DoubleVector3(1f, 1f, 1f);
+            }
+        }
+
+        public static DoubleVector3 forward
+        {
+            get
+            {
+                return new DoubleVector3(0f, 0f, 1f);
+            }
+        }
+
+        public static DoubleVector3 back
+        {
+            get
+            {
+                return new DoubleVector3(0f, 0f, -1f);
+            }
+        }
+
+        public static DoubleVector3 up
+        {
+            get
+            {
+                return new DoubleVector3(0f, 1f, 0f);
+            }
+        }
+
+        public static DoubleVector3 down
+        {
+            get
+            {
+                return new DoubleVector3(0f, -1f, 0f);
+            }
+        }
+
+        public static DoubleVector3 left
+        {
+            get
+            {
+                return new DoubleVector3(-1f, 0f, 0f);
+            }
+        }
+
+        public static DoubleVector3 right
+        {
+            get
+            {
+                return new DoubleVector3(1f, 0f, 0f);
+            }
+        }
+
+        [Obsolete("Use DoubleVector3.forward instead.")]
+        public static DoubleVector3 fwd
+        {
+            get
+            {
+                return new DoubleVector3(0f, 0f, 1f);
+            }
+        }
+
+        public DoubleVector3(double x, double y, double z)
+        {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+        }
+
+        public DoubleVector3(double x, double y)
+        {
+            this.x = x;
+            this.y = y;
+            this.z = 0f;
+        }
+        public DoubleVector3(Vector3 v)
+            :this(v.x,v.y,v.z)
+        {
+
+        }
+
+        public static DoubleVector3 Lerp(DoubleVector3 a, DoubleVector3 b, double t)
+        {
+            t = Math.Max(0.0, Math.Min(1.0, t));
+            return new DoubleVector3(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t);
+        }
+
+        public static DoubleVector3 LerpUnclamped(DoubleVector3 a, DoubleVector3 b, double t)
+        {
+            return new DoubleVector3(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t);
+        }
+
+        public static DoubleVector3 MoveTowards(DoubleVector3 current, DoubleVector3 target, double maxDistanceDelta)
+        {
+            DoubleVector3 a = target - current;
+            double magnitude = a.magnitude;
+            DoubleVector3 result;
+            if (magnitude <= maxDistanceDelta || magnitude == 0f)
+            {
+                result = target;
+            }
+            else
+            {
+                result = current + a / magnitude * maxDistanceDelta;
+            }
+            return result;
+        }
+
+        public void Set(double new_x, double new_y, double new_z)
+        {
+            this.x = new_x;
+            this.y = new_y;
+            this.z = new_z;
+        }
+
+        public static DoubleVector3 Scale(DoubleVector3 a, DoubleVector3 b)
+        {
+            return new DoubleVector3(a.x * b.x, a.y * b.y, a.z * b.z);
+        }
+
+        public void Scale(DoubleVector3 scale)
+        {
+            this.x *= scale.x;
+            this.y *= scale.y;
+            this.z *= scale.z;
+        }
+
+        public static DoubleVector3 Cross(DoubleVector3 lhs, DoubleVector3 rhs)
+        {
+            return new DoubleVector3(lhs.y * rhs.z - lhs.z * rhs.y, lhs.z * rhs.x - lhs.x * rhs.z, lhs.x * rhs.y - lhs.y * rhs.x);
+        }
+
+        public override int GetHashCode()
+        {
+            return this.x.GetHashCode() ^ this.y.GetHashCode() << 2 ^ this.z.GetHashCode() >> 2;
+        }
+
+        public override bool Equals(object other)
+        {
+            bool result;
+            if (!(other is DoubleVector3))
+            {
+                result = false;
+            }
+            else
+            {
+                DoubleVector3 vector = (DoubleVector3)other;
+                result = (this.x.Equals(vector.x) && this.y.Equals(vector.y) && this.z.Equals(vector.z));
+            }
+            return result;
+        }
+
+        public static DoubleVector3 Reflect(DoubleVector3 inDirection, DoubleVector3 inNormal)
+        {
+            return -2f * DoubleVector3.Dot(inNormal, inDirection) * inNormal + inDirection;
+        }
+
+        public static DoubleVector3 Normalize(DoubleVector3 value)
+        {
+            double num = DoubleVector3.Magnitude(value);
+            DoubleVector3 result;
+            if (num > 1E-05f)
+            {
+                result = value / num;
+            }
+            else
+            {
+                result = DoubleVector3.zero;
+            }
+            return result;
+        }
+
+        public void Normalize()
+        {
+            double num = DoubleVector3.Magnitude(this);
+            if (num > 1E-05f)
+            {
+                this /= num;
+            }
+            else
+            {
+                this = DoubleVector3.zero;
+            }
+        }
+
+        public static double Dot(DoubleVector3 lhs, DoubleVector3 rhs)
+        {
+            return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
+        }
+
+
+
+
+        public static double Distance(DoubleVector3 a, DoubleVector3 b)
+        {
+            DoubleVector3 vector = new DoubleVector3(a.x - b.x, a.y - b.y, a.z - b.z);
+            return Math.Sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z);
+        }
+
+        public static DoubleVector3 ClampMagnitude(DoubleVector3 vector, double maxLength)
+        {
+            DoubleVector3 result;
+            if (vector.sqrMagnitude > maxLength * maxLength)
+            {
+                result = vector.normalized * maxLength;
+            }
+            else
+            {
+                result = vector;
+            }
+            return result;
+        }
+
+        public static double Magnitude(DoubleVector3 a)
+        {
+            return Math.Sqrt(a.x * a.x + a.y * a.y + a.z * a.z);
+        }
+
+        public static double SqrMagnitude(DoubleVector3 a)
+        {
+            return a.x * a.x + a.y * a.y + a.z * a.z;
+        }
+
+        public static DoubleVector3 Min(DoubleVector3 lhs, DoubleVector3 rhs)
+        {
+            return new DoubleVector3(Math.Min(lhs.x, rhs.x), Math.Min(lhs.y, rhs.y), Math.Min(lhs.z, rhs.z));
+        }
+
+        public static DoubleVector3 Max(DoubleVector3 lhs, DoubleVector3 rhs)
+        {
+            return new DoubleVector3(Math.Max(lhs.x, rhs.x), Math.Max(lhs.y, rhs.y), Math.Max(lhs.z, rhs.z));
+        }
+
+        public static DoubleVector3 operator +(DoubleVector3 a, DoubleVector3 b)
+        {
+            return new DoubleVector3(a.x + b.x, a.y + b.y, a.z + b.z);
+        }
+
+        public static DoubleVector3 operator -(DoubleVector3 a, DoubleVector3 b)
+        {
+            return new DoubleVector3(a.x - b.x, a.y - b.y, a.z - b.z);
+        }
+
+        public static DoubleVector3 operator -(DoubleVector3 a)
+        {
+            return new DoubleVector3(-a.x, -a.y, -a.z);
+        }
+
+        public static DoubleVector3 operator *(DoubleVector3 a, double d)
+        {
+            return new DoubleVector3(a.x * d, a.y * d, a.z * d);
+        }
+
+        public static DoubleVector3 operator *(double d, DoubleVector3 a)
+        {
+            return new DoubleVector3(a.x * d, a.y * d, a.z * d);
+        }
+
+        public static DoubleVector3 operator /(DoubleVector3 a, double d)
+        {
+            return new DoubleVector3(a.x / d, a.y / d, a.z / d);
+        }
+
+        public static bool operator ==(DoubleVector3 lhs, DoubleVector3 rhs)
+        {
+            return DoubleVector3.SqrMagnitude(lhs - rhs) < 9.99999944E-11f;
+        }
+
+        public static bool operator !=(DoubleVector3 lhs, DoubleVector3 rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+        public override string ToString()
+        {
+            return String.Format("({0}, {1}, {2})", new object[]
+            {
+                this.x,
+                this.y,
+                this.z
+            });
+        }
+
+        public string ToString(string format)
+        {
+            return String.Format("({0}, {1}, {2})", new object[]
+            {
+                this.x.ToString(format),
+                this.y.ToString(format),
+                this.z.ToString(format)
+            });
+        }
+    }
+}

Assets/Chart And Graph/Script/Common/DoubleVector3.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 361dc8ee6dec9ac428fd1ae2c5259fba
+timeCreated: 1500148138
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Chart And Graph/Script/Common/DoubleVector4.cs

@@ -0,0 +1,36 @@
+#define Graph_And_Chart_PRO
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+
+namespace ChartAndGraph
+{
+    public class DoubleVector4
+    {
+        public double x, y, z, w;
+        public DoubleVector4(double _x,double _y,double _z,double _w)
+        {
+            x = _x;
+            y = _y;
+            z = _z;
+            w = _w;
+        }
+
+        public Vector4 ToVector4()
+        {
+            return new Vector4((float)x, (float)y, (float)z,(float)w);
+        }
+
+        public Vector3 ToVector3()
+        {
+            return new Vector3((float)x, (float)y, (float)z);
+        }
+
+        public DoubleVector3 ToDoubleVector3()
+        {
+            return new DoubleVector3(x, y, z);
+        }
+    }
+}

Assets/Chart And Graph/Script/Common/DoubleVector4.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 150232b5475a8924091cdd12f07c4042
+timeCreated: 1500160171
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Chart And Graph/Script/Common/GameObjectPool.cs

@@ -0,0 +1,61 @@
+#define Graph_And_Chart_PRO
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+
+namespace ChartAndGraph
+{
+    /// <summary>
+    /// pools gameobjects for repeated use
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    class GameObjectPool<T> where T : MonoBehaviour
+    {
+        List<T> mPool = new List<T>();
+        public void RecycleObject(T obj)
+        {
+            mPool.Add(obj);
+        }
+
+        public T TakeObject()
+        {
+            if (mPool.Count == 0)
+                return default(T);
+            int last = mPool.Count - 1;
+            T res = mPool[last];
+            mPool.RemoveAt(last);
+            if (res.gameObject.activeInHierarchy == false)
+                res.gameObject.SetActive(true);
+            return res;
+        }
+
+        public void DestoryAll()
+        {
+            for (int i = 0; i < mPool.Count; i++)
+            {
+                T t = mPool[i];
+                if (t != null && t.gameObject != null)
+                {
+                    ChartCommon.SafeDestroy(t.gameObject);
+                }
+            }
+            mPool.Clear();
+        }
+
+        public void DeactivateObjects()
+        {
+            for (int i = 0; i < mPool.Count; i++)
+            {
+                T t = mPool[i];
+                if (t != null && t.gameObject != null)
+                {
+                    if (t.gameObject.activeInHierarchy)
+                        t.gameObject.SetActive(false);
+                }
+            }
+        }
+
+    }
+}

Assets/Chart And Graph/Script/Common/GameObjectPool.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f661eefee5b1c5d4d90ecc8a7d747b03
+timeCreated: 1501931785
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Chart And Graph/Script/Common/ICanvas.cs

@@ -0,0 +1,15 @@
+#define Graph_And_Chart_PRO
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ChartAndGraph
+{
+    /// <summary>
+    /// This is used in order to mark charts that are rendered on canvas
+    /// </summary>
+    public interface ICanvas
+    {
+    }
+}

Assets/Chart And Graph/Script/Common/ICanvas.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ccb0f0e3df7532642aaae116c6b56830
+timeCreated: 1479124371
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: