Replace float with real_t, default Vectors, other misc C# improvements

Replace float with real_t in most files, defined at the top of each file via using. Objects such as Vector3 now accept doubles as inputs, and convert to real_t internally. I've added default Vectors such as Vector3.Zero. Other misc C# improvements such as Mathf.RoundToInt(). Color continues to use float only because high precision is not needed for 8-bit color math and to keep things simple. Everything seems to compile and work fine, but testing is requested, as this is the first time I've ever contributed to Godot.

1 files changed, 68 insertions, 27 deletions

diff --git a/modules/mono/glue/cs_files/Vector2.cs b/modules/mono/glue/cs_files/Vector2.cs
index 238775bda2..6fbe374611 100644
--- a/modules/mono/glue/cs_files/Vector2.cs
+++ b/modules/mono/glue/cs_files/Vector2.cs
@@ -8,15 +8,21 @@ using System.Runtime.InteropServices;
 // file: core/variant_call.cpp
 // commit: 5ad9be4c24e9d7dc5672fdc42cea896622fe5685
 
+#if REAL_T_IS_DOUBLE
+using real_t = System.Double;
+#else
+using real_t = System.Single;
+#endif
+
 namespace Godot
 {
     [StructLayout(LayoutKind.Sequential)]
     public struct Vector2 : IEquatable<Vector2>
     {
-        public float x;
-        public float y;
+        public real_t x;
+        public real_t y;
 
-        public float this[int index]
+        public real_t this[int index]
         {
             get
             {
@@ -48,7 +54,7 @@ namespace Godot
 
         internal void Normalize()
         {
-            float length = x * x + y * y;
+            real_t length = x * x + y * y;
 
             if (length != 0f)
             {
@@ -58,7 +64,7 @@ namespace Godot
             }
         }
 
-        private float Cross(Vector2 b)
+        private real_t Cross(Vector2 b)
         {
             return x * b.y - y * b.x;
         }
@@ -68,22 +74,22 @@ namespace Godot
             return new Vector2(Mathf.Abs(x), Mathf.Abs(y));
         }
 
-        public float Angle()
+        public real_t Angle()
         {
             return Mathf.Atan2(y, x);
         }
 
-        public float AngleTo(Vector2 to)
+        public real_t AngleTo(Vector2 to)
         {
             return Mathf.Atan2(Cross(to), Dot(to));
         }
 
-        public float AngleToPoint(Vector2 to)
+        public real_t AngleToPoint(Vector2 to)
         {
             return Mathf.Atan2(x - to.x, y - to.y);
         }
 
-        public float Aspect()
+        public real_t Aspect()
         {
             return x / y;
         }
@@ -93,10 +99,10 @@ namespace Godot
             return -Reflect(n);
         }
 
-        public Vector2 Clamped(float length)
+        public Vector2 Clamped(real_t length)
         {
             Vector2 v = this;
-            float l = this.Length();
+            real_t l = this.Length();
 
             if (l > 0 && length < l)
             {
@@ -107,15 +113,15 @@ namespace Godot
             return v;
         }
 
-        public Vector2 CubicInterpolate(Vector2 b, Vector2 preA, Vector2 postB, float t)
+        public Vector2 CubicInterpolate(Vector2 b, Vector2 preA, Vector2 postB, real_t t)
         {
             Vector2 p0 = preA;
             Vector2 p1 = this;
             Vector2 p2 = b;
             Vector2 p3 = postB;
 
-            float t2 = t * t;
-            float t3 = t2 * t;
+            real_t t2 = t * t;
+            real_t t3 = t2 * t;
 
             return 0.5f * ((p1 * 2.0f) +
                                 (-p0 + p2) * t +
@@ -123,17 +129,17 @@ namespace Godot
                                 (-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t3);
         }
 
-        public float DistanceSquaredTo(Vector2 to)
+        public real_t DistanceSquaredTo(Vector2 to)
         {
             return (x - to.x) * (x - to.x) + (y - to.y) * (y - to.y);
         }
 
-        public float DistanceTo(Vector2 to)
+        public real_t DistanceTo(Vector2 to)
         {
             return Mathf.Sqrt((x - to.x) * (x - to.x) + (y - to.y) * (y - to.y));
         }
 
-        public float Dot(Vector2 with)
+        public real_t Dot(Vector2 with)
         {
             return x * with.x + y * with.y;
         }
@@ -148,17 +154,17 @@ namespace Godot
             return Mathf.Abs(LengthSquared() - 1.0f) < Mathf.Epsilon;
         }
 
-        public float Length()
+        public real_t Length()
         {
             return Mathf.Sqrt(x * x + y * y);
         }
 
-        public float LengthSquared()
+        public real_t LengthSquared()
         {
             return x * x + y * y;
         }
 
-        public Vector2 LinearInterpolate(Vector2 b, float t)
+        public Vector2 LinearInterpolate(Vector2 b, real_t t)
         {
             Vector2 res = this;
 
@@ -180,12 +186,23 @@ namespace Godot
             return 2.0f * n * Dot(n) - this;
         }
 
-        public Vector2 Rotated(float phi)
+        public Vector2 Rotated(real_t phi)
         {
-            float rads = Angle() + phi;
+            real_t rads = Angle() + phi;
             return new Vector2(Mathf.Cos(rads), Mathf.Sin(rads)) * Length();
         }
 
+        public void Set(real_t x, real_t y)
+        {
+            this.x = x;
+            this.y = y;
+        }
+        public void Set(Vector2 v)
+        {
+            this.x = v.x;
+            this.y = v.y;
+        }
+
         public Vector2 Slide(Vector2 n)
         {
             return this - n * Dot(n);
@@ -200,12 +217,36 @@ namespace Godot
         {
             return new Vector2(y, -x);
         }
-
-        public Vector2(float x, float y)
+        
+        private static readonly Vector2 zero   = new Vector2 (0, 0);
+        private static readonly Vector2 one    = new Vector2 (1, 1);
+        private static readonly Vector2 negOne = new Vector2 (-1, -1);
+    
+        private static readonly Vector2 up     = new Vector2 (0, 1);
+        private static readonly Vector2 down   = new Vector2 (0, -1);
+        private static readonly Vector2 right  = new Vector2 (1, 0);
+        private static readonly Vector2 left   = new Vector2 (-1, 0);
+
+        public static Vector2 Zero   { get { return zero;    } }
+        public static Vector2 One    { get { return one;     } }
+        public static Vector2 NegOne { get { return negOne;  } }
+        
+        public static Vector2 Up     { get { return up;      } }
+        public static Vector2 Down   { get { return down;    } }
+        public static Vector2 Right  { get { return right;   } }
+        public static Vector2 Left   { get { return left;    } }
+
+        // Constructors
+        public Vector2(real_t x, real_t y)
         {
             this.x = x;
             this.y = y;
         }
+        public Vector2(Vector2 v)
+        {
+            this.x = v.x;
+            this.y = v.y;
+        }
 
         public static Vector2 operator +(Vector2 left, Vector2 right)
         {
@@ -228,14 +269,14 @@ namespace Godot
             return vec;
         }
 
-        public static Vector2 operator *(Vector2 vec, float scale)
+        public static Vector2 operator *(Vector2 vec, real_t scale)
         {
             vec.x *= scale;
             vec.y *= scale;
             return vec;
         }
 
-        public static Vector2 operator *(float scale, Vector2 vec)
+        public static Vector2 operator *(real_t scale, Vector2 vec)
         {
             vec.x *= scale;
             vec.y *= scale;
@@ -249,7 +290,7 @@ namespace Godot
             return left;
         }
 
-        public static Vector2 operator /(Vector2 vec, float scale)
+        public static Vector2 operator /(Vector2 vec, real_t scale)
         {
             vec.x /= scale;
             vec.y /= scale;