Convert DOS line endings to Unix line endings

Should fix issues some of us have with `misc/dist/uwp_template/AppxManifest.xml`
always showing up as modified.
Might cause issues on Windows due to the removal of BOMs or change of line endings
in some of the Mono, UWP or gradlew.bat files, we will test and adapt if need be.

7 files changed, 1296 insertions, 1296 deletions

diff --git a/modules/mono/editor/GodotSharpTools/GodotSharpTools.sln b/modules/mono/editor/GodotSharpTools/GodotSharpTools.sln
index 7eabcdff5d..5f7d0e8a39 100644
--- a/modules/mono/editor/GodotSharpTools/GodotSharpTools.sln
+++ b/modules/mono/editor/GodotSharpTools/GodotSharpTools.sln
@@ -1,17 +1,17 @@
-

-Microsoft Visual Studio Solution File, Format Version 12.00

-# Visual Studio 2012

-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GodotSharpTools", "GodotSharpTools.csproj", "{A8CDAD94-C6D4-4B19-A7E7-76C53CC92984}"

-EndProject

-Global

-	GlobalSection(SolutionConfigurationPlatforms) = preSolution

-		Debug|Any CPU = Debug|Any CPU

-		Release|Any CPU = Release|Any CPU

-	EndGlobalSection

-	GlobalSection(ProjectConfigurationPlatforms) = postSolution

-		{A8CDAD94-C6D4-4B19-A7E7-76C53CC92984}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

-		{A8CDAD94-C6D4-4B19-A7E7-76C53CC92984}.Debug|Any CPU.Build.0 = Debug|Any CPU

-		{A8CDAD94-C6D4-4B19-A7E7-76C53CC92984}.Release|Any CPU.ActiveCfg = Release|Any CPU

-		{A8CDAD94-C6D4-4B19-A7E7-76C53CC92984}.Release|Any CPU.Build.0 = Release|Any CPU

-	EndGlobalSection

-EndGlobal

+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GodotSharpTools", "GodotSharpTools.csproj", "{A8CDAD94-C6D4-4B19-A7E7-76C53CC92984}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{A8CDAD94-C6D4-4B19-A7E7-76C53CC92984}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A8CDAD94-C6D4-4B19-A7E7-76C53CC92984}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A8CDAD94-C6D4-4B19-A7E7-76C53CC92984}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A8CDAD94-C6D4-4B19-A7E7-76C53CC92984}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal
diff --git a/modules/mono/glue/cs_files/Color.cs b/modules/mono/glue/cs_files/Color.cs
index df88a46832..0a00f83d47 100644
--- a/modules/mono/glue/cs_files/Color.cs
+++ b/modules/mono/glue/cs_files/Color.cs
@@ -1,590 +1,590 @@
-using System;

-

-namespace Godot

-{

-    public struct Color : IEquatable<Color>

-    {

-        public float r;

-        public float g;

-        public float b;

-        public float a;

-

-        public int r8

-        {

-            get

-            {

-                return (int)(r * 255.0f);

-            }

-        }

-

-        public int g8

-        {

-            get

-            {

-                return (int)(g * 255.0f);

-            }

-        }

-

-        public int b8

-        {

-            get

-            {

-                return (int)(b * 255.0f);

-            }

-        }

-

-        public int a8

-        {

-            get

-            {

-                return (int)(a * 255.0f);

-            }

-        }

-

-        public float h

-        {

-            get

-            {

-                float max = Mathf.max(r, Mathf.max(g, b));

-                float min = Mathf.min(r, Mathf.min(g, b));

-

-                float delta = max - min;

-

-                if (delta == 0)

-                    return 0;

-

-                float h;

-

-                if (r == max)

-                    h = (g - b) / delta; // Between yellow & magenta

-                else if (g == max)

-                    h = 2 + (b - r) / delta; // Between cyan & yellow

-                else

-                    h = 4 + (r - g) / delta; // Between magenta & cyan

-

-                h /= 6.0f;

-

-                if (h < 0)

-                    h += 1.0f;

-

-                return h;

-            }

-            set

-            {

-                this = from_hsv(value, s, v);

-            }

-        }

-

-        public float s

-        {

-            get

-            {

-                float max = Mathf.max(r, Mathf.max(g, b));

-                float min = Mathf.min(r, Mathf.min(g, b));

-

-                float delta = max - min;

-

-                return max != 0 ? delta / max : 0;

-            }

-            set

-            {

-                this = from_hsv(h, value, v);

-            }

-        }

-

-        public float v

-        {

-            get

-            {

-                return Mathf.max(r, Mathf.max(g, b));

-            }

-            set

-            {

-                this = from_hsv(h, s, value);

-            }

-        }

-

-        private static readonly Color black = new Color(0f, 0f, 0f, 1.0f);

-

-        public Color Black

-        {

-            get

-            {

-                return black;

-            }

-        }

-

-        public float this [int index]

-        {

-            get

-            {

-                switch (index)

-                {

-                    case 0:

-                        return r;

-                    case 1:

-                        return g;

-                    case 2:

-                        return b;

-                    case 3:

-                        return a;

-                    default:

-                        throw new IndexOutOfRangeException();

-                }

-            }

-            set

-            {

-                switch (index)

-                {

-                    case 0:

-                        r = value;

-                        return;

-                    case 1:

-                        g = value;

-                        return;

-                    case 2:

-                        b = value;

-                        return;

-                    case 3:

-                        a = value;

-                        return;

-                    default:

-                        throw new IndexOutOfRangeException();

-                }

-            }

-        }

-

-        public static void to_hsv(Color color, out float hue, out float saturation, out float value)

-        {

-            int max = Mathf.max(color.r8, Mathf.max(color.g8, color.b8));

-            int min = Mathf.min(color.r8, Mathf.min(color.g8, color.b8));

-

-            float delta = max - min;

-

-            if (delta == 0)

-            {

-                hue = 0;

-            }

-            else

-            {

-                if (color.r == max)

-                    hue = (color.g - color.b) / delta; // Between yellow & magenta

-                else if (color.g == max)

-                    hue = 2 + (color.b - color.r) / delta; // Between cyan & yellow

-                else

-                    hue = 4 + (color.r - color.g) / delta; // Between magenta & cyan

-

-                hue /= 6.0f;

-

-                if (hue < 0)

-                    hue += 1.0f;

-            }

-

-            saturation = (max == 0) ? 0 : 1f - (1f * min / max);

-            value = max / 255f;

-        }

-

-        public static Color from_hsv(float hue, float saturation, float value, float alpha = 1.0f)

-        {

-            if (saturation == 0)

-            {

-                // acp_hromatic (grey)

-                return new Color(value, value, value, alpha);

-            }

-

-            int i;

-            float f, p, q, t;

-

-            hue *= 6.0f;

-            hue %= 6f;

-            i = (int)hue;

-

-            f = hue - i;

-            p = value * (1 - saturation);

-            q = value * (1 - saturation * f);

-            t = value * (1 - saturation * (1 - f));

-

-            switch (i)

-            {

-                case 0: // Red is the dominant color

-                    return new Color(value, t, p, alpha);

-                case 1: // Green is the dominant color

-                    return new Color(q, value, p, alpha);

-                case 2:

-                    return new Color(p, value, t, alpha);

-                case 3: // Blue is the dominant color

-                    return new Color(p, q, value, alpha);

-                case 4:

-                    return new Color(t, p, value, alpha);

-                default: // (5) Red is the dominant color

-                    return new Color(value, p, q, alpha);

-            }

-        }

-

-        public Color blend(Color over)

-        {

-            Color res;

-

-            float sa = 1.0f - over.a;

-            res.a = a * sa + over.a;

-

-            if (res.a == 0)

-            {

-                return new Color(0, 0, 0, 0);

-            }

-            else

-            {

-                res.r = (r * a * sa + over.r * over.a) / res.a;

-                res.g = (g * a * sa + over.g * over.a) / res.a;

-                res.b = (b * a * sa + over.b * over.a) / res.a;

-            }

-

-            return res;

-        }

-

-        public Color contrasted()

-        {

-            return new Color(

-                (r + 0.5f) % 1.0f,

-                (g + 0.5f) % 1.0f,

-                (b + 0.5f) % 1.0f

-            );

-        }

-

-        public float gray()

-        {

-            return (r + g + b) / 3.0f;

-        }

-

-        public Color inverted()

-        {

-            return new Color(

-                1.0f - r,

-                1.0f - g,

-                1.0f - b

-            );

-        }

-

-        public Color linear_interpolate(Color b, float t)

-        {

-            Color res = this;

-

-            res.r += (t * (b.r - this.r));

-            res.g += (t * (b.g - this.g));

-            res.b += (t * (b.b - this.b));

-            res.a += (t * (b.a - this.a));

-

-            return res;

-        }

-

-        public int to_32()

-        {

-            int c = (byte)(a * 255);

-            c <<= 8;

-            c |= (byte)(r * 255);

-            c <<= 8;

-            c |= (byte)(g * 255);

-            c <<= 8;

-            c |= (byte)(b * 255);

-

-            return c;

-        }

-

-        public int to_ARGB32()

-        {

-            int c = (byte)(a * 255);

-            c <<= 8;

-            c |= (byte)(r * 255);

-            c <<= 8;

-            c |= (byte)(g * 255);

-            c <<= 8;

-            c |= (byte)(b * 255);

-

-            return c;

-        }

-

-        public string to_html(bool include_alpha = true)

-        {

-            String txt = string.Empty;

-

-            txt += _to_hex(r);

-            txt += _to_hex(g);

-            txt += _to_hex(b);

-

-            if (include_alpha)

-                txt = _to_hex(a) + txt;

-

-            return txt;

-        }

-

-        public Color(float r, float g, float b, float a = 1.0f)

-        {

-            this.r = r;

-            this.g = g;

-            this.b = b;

-            this.a = a;

-        }

-

-        public Color(int rgba)

-        {

-            this.a = (rgba & 0xFF) / 255.0f;

-            rgba >>= 8;

-            this.b = (rgba & 0xFF) / 255.0f;

-            rgba >>= 8;

-            this.g = (rgba & 0xFF) / 255.0f;

-            rgba >>= 8;

-            this.r = (rgba & 0xFF) / 255.0f;

-        }

-

-        private static float _parse_col(string str, int ofs)

-        {

-            int ig = 0;

-

-            for (int i = 0; i < 2; i++)

-            {

-                int c = str[i + ofs];

-                int v = 0;

-

-                if (c >= '0' && c <= '9')

-                {

-                    v = c - '0';

-                }

-                else if (c >= 'a' && c <= 'f')

-                {

-                    v = c - 'a';

-                    v += 10;

-                }

-                else if (c >= 'A' && c <= 'F')

-                {

-                    v = c - 'A';

-                    v += 10;

-                }

-                else

-                {

-                    return -1;

-                }

-

-                if (i == 0)

-                    ig += v * 16;

-                else

-                    ig += v;

-            }

-

-            return ig;

-        }

-

-        private String _to_hex(float val)

-        {

-            int v = (int)Mathf.clamp(val * 255.0f, 0, 255);

-

-            string ret = string.Empty;

-

-            for (int i = 0; i < 2; i++)

-            {

-                char[] c = { (char)0, (char)0 };

-                int lv = v & 0xF;

-

-                if (lv < 10)

-                    c[0] = (char)('0' + lv);

-                else

-                    c[0] = (char)('a' + lv - 10);

-

-                v >>= 4;

-                ret = c + ret;

-            }

-

-            return ret;

-        }

-

-        internal static bool html_is_valid(string color)

-        {

-            if (color.Length == 0)

-                return false;

-

-            if (color[0] == '#')

-                color = color.Substring(1, color.Length - 1);

-

-            bool alpha = false;

-

-            if (color.Length == 8)

-                alpha = true;

-            else if (color.Length == 6)

-                alpha = false;

-            else

-                return false;

-

-            if (alpha)

-            {

-                if ((int)_parse_col(color, 0) < 0)

-                    return false;

-            }

-

-            int from = alpha ? 2 : 0;

-

-            if ((int)_parse_col(color, from + 0) < 0)

-                return false;

-            if ((int)_parse_col(color, from + 2) < 0)

-                return false;

-            if ((int)_parse_col(color, from + 4) < 0)

-                return false;

-

-            return true;

-        }

-

-        public static Color Color8(byte r8, byte g8, byte b8, byte a8)

-        {

-            return new Color((float)r8 / 255f, (float)g8 / 255f, (float)b8 / 255f, (float)a8 / 255f);

-        }

-

-        public Color(string rgba)

-        {

-            if (rgba.Length == 0)

-            {

-                r = 0f;

-                g = 0f;

-                b = 0f;

-                a = 1.0f;

-                return;

-            }

-

-            if (rgba[0] == '#')

-                rgba = rgba.Substring(1);

-

-            bool alpha = false;

-

-            if (rgba.Length == 8)

-            {

-                alpha = true;

-            }

-            else if (rgba.Length == 6)

-            {

-                alpha = false;

-            }

-            else

-            {

-                throw new ArgumentOutOfRangeException("Invalid color code. Length is " + rgba.Length + " but a length of 6 or 8 is expected: " + rgba);

-            }

-

-            if (alpha)

-            {

-                a = _parse_col(rgba, 0);

-

-                if (a < 0)

-                    throw new ArgumentOutOfRangeException("Invalid color code. Alpha is " + a + " but zero or greater is expected: " + rgba);

-            }

-            else

-            {

-                a = 1.0f;

-            }

-

-            int from = alpha ? 2 : 0;

-

-            r = _parse_col(rgba, from + 0);

-

-            if (r < 0)

-                throw new ArgumentOutOfRangeException("Invalid color code. Red is " + r + " but zero or greater is expected: " + rgba);

-

-            g = _parse_col(rgba, from + 2);

-

-            if (g < 0)

-                throw new ArgumentOutOfRangeException("Invalid color code. Green is " + g + " but zero or greater is expected: " + rgba);

-

-            b = _parse_col(rgba, from + 4);

-

-            if (b < 0)

-                throw new ArgumentOutOfRangeException("Invalid color code. Blue is " + b + " but zero or greater is expected: " + rgba);

-        }

-

-        public static bool operator ==(Color left, Color right)

-        {

-            return left.Equals(right);

-        }

-

-        public static bool operator !=(Color left, Color right)

-        {

-            return !left.Equals(right);

-        }

-

-        public static bool operator <(Color left, Color right)

-        {

-            if (left.r == right.r)

-            {

-                if (left.g == right.g)

-                {

-                    if (left.b == right.b)

-                        return (left.a < right.a);

-                    else

-                        return (left.b < right.b);

-                }

-                else

-                {

-                    return left.g < right.g;

-                }

-            }

-

-            return left.r < right.r;

-        }

-

-        public static bool operator >(Color left, Color right)

-        {

-            if (left.r == right.r)

-            {

-                if (left.g == right.g)

-                {

-                    if (left.b == right.b)

-                        return (left.a > right.a);

-                    else

-                        return (left.b > right.b);

-                }

-                else

-                {

-                    return left.g > right.g;

-                }

-            }

-

-            return left.r > right.r;

-        }

-

-        public override bool Equals(object obj)

-        {

-            if (obj is Color)

-            {

-                return Equals((Color)obj);

-            }

-

-            return false;

-        }

-

-        public bool Equals(Color other)

-        {

-            return r == other.r && g == other.g && b == other.b && a == other.a;

-        }

-

-        public override int GetHashCode()

-        {

-            return r.GetHashCode() ^ g.GetHashCode() ^ b.GetHashCode() ^ a.GetHashCode();

-        }

-

-        public override string ToString()

-        {

-            return String.Format("{0},{1},{2},{3}", new object[]

-                {

-                    this.r.ToString(),

-                    this.g.ToString(),

-                    this.b.ToString(),

-                    this.a.ToString()

-                });

-        }

-

-        public string ToString(string format)

-        {

-            return String.Format("{0},{1},{2},{3}", new object[]

-                {

-                    this.r.ToString(format),

-                    this.g.ToString(format),

-                    this.b.ToString(format),

-                    this.a.ToString(format)

-                });

-        }

-    }

-}

+using System;
+
+namespace Godot
+{
+    public struct Color : IEquatable<Color>
+    {
+        public float r;
+        public float g;
+        public float b;
+        public float a;
+
+        public int r8
+        {
+            get
+            {
+                return (int)(r * 255.0f);
+            }
+        }
+
+        public int g8
+        {
+            get
+            {
+                return (int)(g * 255.0f);
+            }
+        }
+
+        public int b8
+        {
+            get
+            {
+                return (int)(b * 255.0f);
+            }
+        }
+
+        public int a8
+        {
+            get
+            {
+                return (int)(a * 255.0f);
+            }
+        }
+
+        public float h
+        {
+            get
+            {
+                float max = Mathf.max(r, Mathf.max(g, b));
+                float min = Mathf.min(r, Mathf.min(g, b));
+
+                float delta = max - min;
+
+                if (delta == 0)
+                    return 0;
+
+                float h;
+
+                if (r == max)
+                    h = (g - b) / delta; // Between yellow & magenta
+                else if (g == max)
+                    h = 2 + (b - r) / delta; // Between cyan & yellow
+                else
+                    h = 4 + (r - g) / delta; // Between magenta & cyan
+
+                h /= 6.0f;
+
+                if (h < 0)
+                    h += 1.0f;
+
+                return h;
+            }
+            set
+            {
+                this = from_hsv(value, s, v);
+            }
+        }
+
+        public float s
+        {
+            get
+            {
+                float max = Mathf.max(r, Mathf.max(g, b));
+                float min = Mathf.min(r, Mathf.min(g, b));
+
+                float delta = max - min;
+
+                return max != 0 ? delta / max : 0;
+            }
+            set
+            {
+                this = from_hsv(h, value, v);
+            }
+        }
+
+        public float v
+        {
+            get
+            {
+                return Mathf.max(r, Mathf.max(g, b));
+            }
+            set
+            {
+                this = from_hsv(h, s, value);
+            }
+        }
+
+        private static readonly Color black = new Color(0f, 0f, 0f, 1.0f);
+
+        public Color Black
+        {
+            get
+            {
+                return black;
+            }
+        }
+
+        public float this [int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0:
+                        return r;
+                    case 1:
+                        return g;
+                    case 2:
+                        return b;
+                    case 3:
+                        return a;
+                    default:
+                        throw new IndexOutOfRangeException();
+                }
+            }
+            set
+            {
+                switch (index)
+                {
+                    case 0:
+                        r = value;
+                        return;
+                    case 1:
+                        g = value;
+                        return;
+                    case 2:
+                        b = value;
+                        return;
+                    case 3:
+                        a = value;
+                        return;
+                    default:
+                        throw new IndexOutOfRangeException();
+                }
+            }
+        }
+
+        public static void to_hsv(Color color, out float hue, out float saturation, out float value)
+        {
+            int max = Mathf.max(color.r8, Mathf.max(color.g8, color.b8));
+            int min = Mathf.min(color.r8, Mathf.min(color.g8, color.b8));
+
+            float delta = max - min;
+
+            if (delta == 0)
+            {
+                hue = 0;
+            }
+            else
+            {
+                if (color.r == max)
+                    hue = (color.g - color.b) / delta; // Between yellow & magenta
+                else if (color.g == max)
+                    hue = 2 + (color.b - color.r) / delta; // Between cyan & yellow
+                else
+                    hue = 4 + (color.r - color.g) / delta; // Between magenta & cyan
+
+                hue /= 6.0f;
+
+                if (hue < 0)
+                    hue += 1.0f;
+            }
+
+            saturation = (max == 0) ? 0 : 1f - (1f * min / max);
+            value = max / 255f;
+        }
+
+        public static Color from_hsv(float hue, float saturation, float value, float alpha = 1.0f)
+        {
+            if (saturation == 0)
+            {
+                // acp_hromatic (grey)
+                return new Color(value, value, value, alpha);
+            }
+
+            int i;
+            float f, p, q, t;
+
+            hue *= 6.0f;
+            hue %= 6f;
+            i = (int)hue;
+
+            f = hue - i;
+            p = value * (1 - saturation);
+            q = value * (1 - saturation * f);
+            t = value * (1 - saturation * (1 - f));
+
+            switch (i)
+            {
+                case 0: // Red is the dominant color
+                    return new Color(value, t, p, alpha);
+                case 1: // Green is the dominant color
+                    return new Color(q, value, p, alpha);
+                case 2:
+                    return new Color(p, value, t, alpha);
+                case 3: // Blue is the dominant color
+                    return new Color(p, q, value, alpha);
+                case 4:
+                    return new Color(t, p, value, alpha);
+                default: // (5) Red is the dominant color
+                    return new Color(value, p, q, alpha);
+            }
+        }
+
+        public Color blend(Color over)
+        {
+            Color res;
+
+            float sa = 1.0f - over.a;
+            res.a = a * sa + over.a;
+
+            if (res.a == 0)
+            {
+                return new Color(0, 0, 0, 0);
+            }
+            else
+            {
+                res.r = (r * a * sa + over.r * over.a) / res.a;
+                res.g = (g * a * sa + over.g * over.a) / res.a;
+                res.b = (b * a * sa + over.b * over.a) / res.a;
+            }
+
+            return res;
+        }
+
+        public Color contrasted()
+        {
+            return new Color(
+                (r + 0.5f) % 1.0f,
+                (g + 0.5f) % 1.0f,
+                (b + 0.5f) % 1.0f
+            );
+        }
+
+        public float gray()
+        {
+            return (r + g + b) / 3.0f;
+        }
+
+        public Color inverted()
+        {
+            return new Color(
+                1.0f - r,
+                1.0f - g,
+                1.0f - b
+            );
+        }
+
+        public Color linear_interpolate(Color b, float t)
+        {
+            Color res = this;
+
+            res.r += (t * (b.r - this.r));
+            res.g += (t * (b.g - this.g));
+            res.b += (t * (b.b - this.b));
+            res.a += (t * (b.a - this.a));
+
+            return res;
+        }
+
+        public int to_32()
+        {
+            int c = (byte)(a * 255);
+            c <<= 8;
+            c |= (byte)(r * 255);
+            c <<= 8;
+            c |= (byte)(g * 255);
+            c <<= 8;
+            c |= (byte)(b * 255);
+
+            return c;
+        }
+
+        public int to_ARGB32()
+        {
+            int c = (byte)(a * 255);
+            c <<= 8;
+            c |= (byte)(r * 255);
+            c <<= 8;
+            c |= (byte)(g * 255);
+            c <<= 8;
+            c |= (byte)(b * 255);
+
+            return c;
+        }
+
+        public string to_html(bool include_alpha = true)
+        {
+            String txt = string.Empty;
+
+            txt += _to_hex(r);
+            txt += _to_hex(g);
+            txt += _to_hex(b);
+
+            if (include_alpha)
+                txt = _to_hex(a) + txt;
+
+            return txt;
+        }
+
+        public Color(float r, float g, float b, float a = 1.0f)
+        {
+            this.r = r;
+            this.g = g;
+            this.b = b;
+            this.a = a;
+        }
+
+        public Color(int rgba)
+        {
+            this.a = (rgba & 0xFF) / 255.0f;
+            rgba >>= 8;
+            this.b = (rgba & 0xFF) / 255.0f;
+            rgba >>= 8;
+            this.g = (rgba & 0xFF) / 255.0f;
+            rgba >>= 8;
+            this.r = (rgba & 0xFF) / 255.0f;
+        }
+
+        private static float _parse_col(string str, int ofs)
+        {
+            int ig = 0;
+
+            for (int i = 0; i < 2; i++)
+            {
+                int c = str[i + ofs];
+                int v = 0;
+
+                if (c >= '0' && c <= '9')
+                {
+                    v = c - '0';
+                }
+                else if (c >= 'a' && c <= 'f')
+                {
+                    v = c - 'a';
+                    v += 10;
+                }
+                else if (c >= 'A' && c <= 'F')
+                {
+                    v = c - 'A';
+                    v += 10;
+                }
+                else
+                {
+                    return -1;
+                }
+
+                if (i == 0)
+                    ig += v * 16;
+                else
+                    ig += v;
+            }
+
+            return ig;
+        }
+
+        private String _to_hex(float val)
+        {
+            int v = (int)Mathf.clamp(val * 255.0f, 0, 255);
+
+            string ret = string.Empty;
+
+            for (int i = 0; i < 2; i++)
+            {
+                char[] c = { (char)0, (char)0 };
+                int lv = v & 0xF;
+
+                if (lv < 10)
+                    c[0] = (char)('0' + lv);
+                else
+                    c[0] = (char)('a' + lv - 10);
+
+                v >>= 4;
+                ret = c + ret;
+            }
+
+            return ret;
+        }
+
+        internal static bool html_is_valid(string color)
+        {
+            if (color.Length == 0)
+                return false;
+
+            if (color[0] == '#')
+                color = color.Substring(1, color.Length - 1);
+
+            bool alpha = false;
+
+            if (color.Length == 8)
+                alpha = true;
+            else if (color.Length == 6)
+                alpha = false;
+            else
+                return false;
+
+            if (alpha)
+            {
+                if ((int)_parse_col(color, 0) < 0)
+                    return false;
+            }
+
+            int from = alpha ? 2 : 0;
+
+            if ((int)_parse_col(color, from + 0) < 0)
+                return false;
+            if ((int)_parse_col(color, from + 2) < 0)
+                return false;
+            if ((int)_parse_col(color, from + 4) < 0)
+                return false;
+
+            return true;
+        }
+
+        public static Color Color8(byte r8, byte g8, byte b8, byte a8)
+        {
+            return new Color((float)r8 / 255f, (float)g8 / 255f, (float)b8 / 255f, (float)a8 / 255f);
+        }
+
+        public Color(string rgba)
+        {
+            if (rgba.Length == 0)
+            {
+                r = 0f;
+                g = 0f;
+                b = 0f;
+                a = 1.0f;
+                return;
+            }
+
+            if (rgba[0] == '#')
+                rgba = rgba.Substring(1);
+
+            bool alpha = false;
+
+            if (rgba.Length == 8)
+            {
+                alpha = true;
+            }
+            else if (rgba.Length == 6)
+            {
+                alpha = false;
+            }
+            else
+            {
+                throw new ArgumentOutOfRangeException("Invalid color code. Length is " + rgba.Length + " but a length of 6 or 8 is expected: " + rgba);
+            }
+
+            if (alpha)
+            {
+                a = _parse_col(rgba, 0);
+
+                if (a < 0)
+                    throw new ArgumentOutOfRangeException("Invalid color code. Alpha is " + a + " but zero or greater is expected: " + rgba);
+            }
+            else
+            {
+                a = 1.0f;
+            }
+
+            int from = alpha ? 2 : 0;
+
+            r = _parse_col(rgba, from + 0);
+
+            if (r < 0)
+                throw new ArgumentOutOfRangeException("Invalid color code. Red is " + r + " but zero or greater is expected: " + rgba);
+
+            g = _parse_col(rgba, from + 2);
+
+            if (g < 0)
+                throw new ArgumentOutOfRangeException("Invalid color code. Green is " + g + " but zero or greater is expected: " + rgba);
+
+            b = _parse_col(rgba, from + 4);
+
+            if (b < 0)
+                throw new ArgumentOutOfRangeException("Invalid color code. Blue is " + b + " but zero or greater is expected: " + rgba);
+        }
+
+        public static bool operator ==(Color left, Color right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(Color left, Color right)
+        {
+            return !left.Equals(right);
+        }
+
+        public static bool operator <(Color left, Color right)
+        {
+            if (left.r == right.r)
+            {
+                if (left.g == right.g)
+                {
+                    if (left.b == right.b)
+                        return (left.a < right.a);
+                    else
+                        return (left.b < right.b);
+                }
+                else
+                {
+                    return left.g < right.g;
+                }
+            }
+
+            return left.r < right.r;
+        }
+
+        public static bool operator >(Color left, Color right)
+        {
+            if (left.r == right.r)
+            {
+                if (left.g == right.g)
+                {
+                    if (left.b == right.b)
+                        return (left.a > right.a);
+                    else
+                        return (left.b > right.b);
+                }
+                else
+                {
+                    return left.g > right.g;
+                }
+            }
+
+            return left.r > right.r;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is Color)
+            {
+                return Equals((Color)obj);
+            }
+
+            return false;
+        }
+
+        public bool Equals(Color other)
+        {
+            return r == other.r && g == other.g && b == other.b && a == other.a;
+        }
+
+        public override int GetHashCode()
+        {
+            return r.GetHashCode() ^ g.GetHashCode() ^ b.GetHashCode() ^ a.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return String.Format("{0},{1},{2},{3}", new object[]
+                {
+                    this.r.ToString(),
+                    this.g.ToString(),
+                    this.b.ToString(),
+                    this.a.ToString()
+                });
+        }
+
+        public string ToString(string format)
+        {
+            return String.Format("{0},{1},{2},{3}", new object[]
+                {
+                    this.r.ToString(format),
+                    this.g.ToString(format),
+                    this.b.ToString(format),
+                    this.a.ToString(format)
+                });
+        }
+    }
+}
diff --git a/modules/mono/glue/cs_files/ExportAttribute.cs b/modules/mono/glue/cs_files/ExportAttribute.cs
index a4e7d447dd..dce9cc59a0 100644
--- a/modules/mono/glue/cs_files/ExportAttribute.cs
+++ b/modules/mono/glue/cs_files/ExportAttribute.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace Godot
 {
diff --git a/modules/mono/glue/cs_files/MarshalUtils.cs b/modules/mono/glue/cs_files/MarshalUtils.cs
index 5d40111339..2bdfb95c51 100644
--- a/modules/mono/glue/cs_files/MarshalUtils.cs
+++ b/modules/mono/glue/cs_files/MarshalUtils.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 
 namespace Godot
diff --git a/modules/mono/glue/cs_files/Plane.cs b/modules/mono/glue/cs_files/Plane.cs
index ada6e465ac..37f70aca1e 100644
--- a/modules/mono/glue/cs_files/Plane.cs
+++ b/modules/mono/glue/cs_files/Plane.cs
@@ -1,209 +1,209 @@
-using System;

-

-namespace Godot

-{

-    public struct Plane : IEquatable<Plane>

-    {

-        Vector3 normal;

-

-        public float x

-        {

-            get

-            {

-                return normal.x;

-            }

-            set

-            {

-                normal.x = value;

-            }

-        }

-

-        public float y

-        {

-            get

-            {

-                return normal.y;

-            }

-            set

-            {

-                normal.y = value;

-            }

-        }

-

-        public float z

-        {

-            get

-            {

-                return normal.z;

-            }

-            set

-            {

-                normal.z = value;

-            }

-        }

-

-        float d;

-

-        public Vector3 Center

-        {

-            get

-            {

-                return normal * d;

-            }

-        }

-

-        public float distance_to(Vector3 point)

-        {

-            return normal.dot(point) - d;

-        }

-

-        public Vector3 get_any_point()

-        {

-            return normal * d;

-        }

-

-        public bool has_point(Vector3 point, float epsilon = Mathf.Epsilon)

-        {

-            float dist = normal.dot(point) - d;

-            return Mathf.abs(dist) <= epsilon;

-        }

-

-        public Vector3 intersect_3(Plane b, Plane c)

-        {

-            float denom = normal.cross(b.normal).dot(c.normal);

-

-            if (Mathf.abs(denom) <= Mathf.Epsilon)

-                return new Vector3();

-

-            Vector3 result = (b.normal.cross(c.normal) * this.d) +

-                                (c.normal.cross(normal) * b.d) +

-                                (normal.cross(b.normal) * c.d);

-

-            return result / denom;

-        }

-

-        public Vector3 intersect_ray(Vector3 from, Vector3 dir)

-        {

-            float den = normal.dot(dir);

-

-            if (Mathf.abs(den) <= Mathf.Epsilon)

-                return new Vector3();

-

-            float dist = (normal.dot(from) - d) / den;

-

-            // This is a ray, before the emiting pos (from) does not exist

-            if (dist > Mathf.Epsilon)

-                return new Vector3();

-

-            return from + dir * -dist;

-        }

-

-        public Vector3 intersect_segment(Vector3 begin, Vector3 end)

-        {

-            Vector3 segment = begin - end;

-            float den = normal.dot(segment);

-

-            if (Mathf.abs(den) <= Mathf.Epsilon)

-                return new Vector3();

-

-            float dist = (normal.dot(begin) - d) / den;

-

-            if (dist < -Mathf.Epsilon || dist > (1.0f + Mathf.Epsilon))

-                return new Vector3();

-

-            return begin + segment * -dist;

-        }

-

-        public bool is_point_over(Vector3 point)

-        {

-            return normal.dot(point) > d;

-        }

-

-        public Plane normalized()

-        {

-            float len = normal.length();

-

-            if (len == 0)

-                return new Plane(0, 0, 0, 0);

-

-            return new Plane(normal / len, d / len);

-        }

-

-        public Vector3 project(Vector3 point)

-        {

-            return point - normal * distance_to(point);

-        }

-

-        public Plane(float a, float b, float c, float d)

-        {

-            normal = new Vector3(a, b, c);

-            this.d = d;

-        }

-

-        public Plane(Vector3 normal, float d)

-        {

-            this.normal = normal;

-            this.d = d;

-        }

-

-        public Plane(Vector3 v1, Vector3 v2, Vector3 v3)

-        {

-            normal = (v1 - v3).cross(v1 - v2);

-            normal.normalize();

-            d = normal.dot(v1);

-        }

-

-        public static Plane operator -(Plane plane)

-        {

-            return new Plane(-plane.normal, -plane.d);

-        }

-

-        public static bool operator ==(Plane left, Plane right)

-        {

-            return left.Equals(right);

-        }

-

-        public static bool operator !=(Plane left, Plane right)

-        {

-            return !left.Equals(right);

-        }

-

-        public override bool Equals(object obj)

-        {

-            if (obj is Plane)

-            {

-                return Equals((Plane)obj);

-            }

-

-            return false;

-        }

-

-        public bool Equals(Plane other)

-        {

-            return normal == other.normal && d == other.d;

-        }

-

-        public override int GetHashCode()

-        {

-            return normal.GetHashCode() ^ d.GetHashCode();

-        }

-

-        public override string ToString()

-        {

-            return String.Format("({0}, {1})", new object[]

-            {

-                this.normal.ToString(),

-                this.d.ToString()

-            });

-        }

-

-        public string ToString(string format)

-        {

-            return String.Format("({0}, {1})", new object[]

-            {

-                this.normal.ToString(format),

-                this.d.ToString(format)

-            });

-        }

-    }

-}

+using System;
+
+namespace Godot
+{
+    public struct Plane : IEquatable<Plane>
+    {
+        Vector3 normal;
+
+        public float x
+        {
+            get
+            {
+                return normal.x;
+            }
+            set
+            {
+                normal.x = value;
+            }
+        }
+
+        public float y
+        {
+            get
+            {
+                return normal.y;
+            }
+            set
+            {
+                normal.y = value;
+            }
+        }
+
+        public float z
+        {
+            get
+            {
+                return normal.z;
+            }
+            set
+            {
+                normal.z = value;
+            }
+        }
+
+        float d;
+
+        public Vector3 Center
+        {
+            get
+            {
+                return normal * d;
+            }
+        }
+
+        public float distance_to(Vector3 point)
+        {
+            return normal.dot(point) - d;
+        }
+
+        public Vector3 get_any_point()
+        {
+            return normal * d;
+        }
+
+        public bool has_point(Vector3 point, float epsilon = Mathf.Epsilon)
+        {
+            float dist = normal.dot(point) - d;
+            return Mathf.abs(dist) <= epsilon;
+        }
+
+        public Vector3 intersect_3(Plane b, Plane c)
+        {
+            float denom = normal.cross(b.normal).dot(c.normal);
+
+            if (Mathf.abs(denom) <= Mathf.Epsilon)
+                return new Vector3();
+
+            Vector3 result = (b.normal.cross(c.normal) * this.d) +
+                                (c.normal.cross(normal) * b.d) +
+                                (normal.cross(b.normal) * c.d);
+
+            return result / denom;
+        }
+
+        public Vector3 intersect_ray(Vector3 from, Vector3 dir)
+        {
+            float den = normal.dot(dir);
+
+            if (Mathf.abs(den) <= Mathf.Epsilon)
+                return new Vector3();
+
+            float dist = (normal.dot(from) - d) / den;
+
+            // This is a ray, before the emiting pos (from) does not exist
+            if (dist > Mathf.Epsilon)
+                return new Vector3();
+
+            return from + dir * -dist;
+        }
+
+        public Vector3 intersect_segment(Vector3 begin, Vector3 end)
+        {
+            Vector3 segment = begin - end;
+            float den = normal.dot(segment);
+
+            if (Mathf.abs(den) <= Mathf.Epsilon)
+                return new Vector3();
+
+            float dist = (normal.dot(begin) - d) / den;
+
+            if (dist < -Mathf.Epsilon || dist > (1.0f + Mathf.Epsilon))
+                return new Vector3();
+
+            return begin + segment * -dist;
+        }
+
+        public bool is_point_over(Vector3 point)
+        {
+            return normal.dot(point) > d;
+        }
+
+        public Plane normalized()
+        {
+            float len = normal.length();
+
+            if (len == 0)
+                return new Plane(0, 0, 0, 0);
+
+            return new Plane(normal / len, d / len);
+        }
+
+        public Vector3 project(Vector3 point)
+        {
+            return point - normal * distance_to(point);
+        }
+
+        public Plane(float a, float b, float c, float d)
+        {
+            normal = new Vector3(a, b, c);
+            this.d = d;
+        }
+
+        public Plane(Vector3 normal, float d)
+        {
+            this.normal = normal;
+            this.d = d;
+        }
+
+        public Plane(Vector3 v1, Vector3 v2, Vector3 v3)
+        {
+            normal = (v1 - v3).cross(v1 - v2);
+            normal.normalize();
+            d = normal.dot(v1);
+        }
+
+        public static Plane operator -(Plane plane)
+        {
+            return new Plane(-plane.normal, -plane.d);
+        }
+
+        public static bool operator ==(Plane left, Plane right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(Plane left, Plane right)
+        {
+            return !left.Equals(right);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is Plane)
+            {
+                return Equals((Plane)obj);
+            }
+
+            return false;
+        }
+
+        public bool Equals(Plane other)
+        {
+            return normal == other.normal && d == other.d;
+        }
+
+        public override int GetHashCode()
+        {
+            return normal.GetHashCode() ^ d.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return String.Format("({0}, {1})", new object[]
+            {
+                this.normal.ToString(),
+                this.d.ToString()
+            });
+        }
+
+        public string ToString(string format)
+        {
+            return String.Format("({0}, {1})", new object[]
+            {
+                this.normal.ToString(format),
+                this.d.ToString(format)
+            });
+        }
+    }
+}
diff --git a/modules/mono/glue/cs_files/Rect3.cs b/modules/mono/glue/cs_files/Rect3.cs
index 0d25de1ec6..617d33e7fd 100644
--- a/modules/mono/glue/cs_files/Rect3.cs
+++ b/modules/mono/glue/cs_files/Rect3.cs
@@ -1,477 +1,477 @@
-using System;

-

-// file: core/math/rect3.h

-// commit: 7ad14e7a3e6f87ddc450f7e34621eb5200808451

-// file: core/math/rect3.cpp

-// commit: bd282ff43f23fe845f29a3e25c8efc01bd65ffb0

-// file: core/variant_call.cpp

-// commit: 5ad9be4c24e9d7dc5672fdc42cea896622fe5685

-

-namespace Godot

-{

-    public struct Rect3 : IEquatable<Rect3>

-    {

-        private Vector3 position;

-        private Vector3 size;

-

-        public Vector3 Position

-        {

-            get

-            {

-                return position;

-            }

-        }

-

-        public Vector3 Size

-        {

-            get

-            {

-                return size;

-            }

-        }

-

-        public Vector3 End

-        {

-            get

-            {

-                return position + size;

-            }

-        }

-

-        public bool encloses(Rect3 with)

-        {

-            Vector3 src_min = position;

-            Vector3 src_max = position + size;

-            Vector3 dst_min = with.position;

-            Vector3 dst_max = with.position + with.size;

-

-            return ((src_min.x <= dst_min.x) &&

-                    (src_max.x > dst_max.x) &&

-                    (src_min.y <= dst_min.y) &&

-                    (src_max.y > dst_max.y) &&

-                    (src_min.z <= dst_min.z) &&

-                    (src_max.z > dst_max.z));

-        }

-

-        public Rect3 expand(Vector3 to_point)

-        {

-            Vector3 begin = position;

-            Vector3 end = position + size;

-

-            if (to_point.x < begin.x)

-                begin.x = to_point.x;

-            if (to_point.y < begin.y)

-                begin.y = to_point.y;

-            if (to_point.z < begin.z)

-                begin.z = to_point.z;

-

-            if (to_point.x > end.x)

-                end.x = to_point.x;

-            if (to_point.y > end.y)

-                end.y = to_point.y;

-            if (to_point.z > end.z)

-                end.z = to_point.z;

-

-            return new Rect3(begin, end - begin);

-        }

-

-        public float get_area()

-        {

-            return size.x * size.y * size.z;

-        }

-

-        public Vector3 get_endpoint(int idx)

-        {

-            switch (idx)

-            {

-                case 0:

-                    return new Vector3(position.x, position.y, position.z);

-                case 1:

-                    return new Vector3(position.x, position.y, position.z + size.z);

-                case 2:

-                    return new Vector3(position.x, position.y + size.y, position.z);

-                case 3:

-                    return new Vector3(position.x, position.y + size.y, position.z + size.z);

-                case 4:

-                    return new Vector3(position.x + size.x, position.y, position.z);

-                case 5:

-                    return new Vector3(position.x + size.x, position.y, position.z + size.z);

-                case 6:

-                    return new Vector3(position.x + size.x, position.y + size.y, position.z);

-                case 7:

-                    return new Vector3(position.x + size.x, position.y + size.y, position.z + size.z);

-                default:

-                    throw new ArgumentOutOfRangeException(nameof(idx), String.Format("Index is {0}, but a value from 0 to 7 is expected.", idx));

-            }

-        }

-

-        public Vector3 get_longest_axis()

-        {

-            Vector3 axis = new Vector3(1f, 0f, 0f);

-            float max_size = size.x;

-

-            if (size.y > max_size)

-            {

-                axis = new Vector3(0f, 1f, 0f);

-                max_size = size.y;

-            }

-

-            if (size.z > max_size)

-            {

-                axis = new Vector3(0f, 0f, 1f);

-                max_size = size.z;

-            }

-

-            return axis;

-        }

-

-        public Vector3.Axis get_longest_axis_index()

-        {

-            Vector3.Axis axis = Vector3.Axis.X;

-            float max_size = size.x;

-

-            if (size.y > max_size)

-            {

-                axis = Vector3.Axis.Y;

-                max_size = size.y;

-            }

-

-            if (size.z > max_size)

-            {

-                axis = Vector3.Axis.Z;

-                max_size = size.z;

-            }

-

-            return axis;

-        }

-

-        public float get_longest_axis_size()

-        {

-            float max_size = size.x;

-

-            if (size.y > max_size)

-                max_size = size.y;

-

-            if (size.z > max_size)

-                max_size = size.z;

-

-            return max_size;

-        }

-

-        public Vector3 get_shortest_axis()

-        {

-            Vector3 axis = new Vector3(1f, 0f, 0f);

-            float max_size = size.x;

-

-            if (size.y < max_size)

-            {

-                axis = new Vector3(0f, 1f, 0f);

-                max_size = size.y;

-            }

-

-            if (size.z < max_size)

-            {

-                axis = new Vector3(0f, 0f, 1f);

-                max_size = size.z;

-            }

-

-            return axis;

-        }

-

-        public Vector3.Axis get_shortest_axis_index()

-        {

-            Vector3.Axis axis = Vector3.Axis.X;

-            float max_size = size.x;

-

-            if (size.y < max_size)

-            {

-                axis = Vector3.Axis.Y;

-                max_size = size.y;

-            }

-

-            if (size.z < max_size)

-            {

-                axis = Vector3.Axis.Z;

-                max_size = size.z;

-            }

-

-            return axis;

-        }

-

-        public float get_shortest_axis_size()

-        {

-            float max_size = size.x;

-

-            if (size.y < max_size)

-                max_size = size.y;

-

-            if (size.z < max_size)

-                max_size = size.z;

-

-            return max_size;

-        }

-

-        public Vector3 get_support(Vector3 dir)

-        {

-            Vector3 half_extents = size * 0.5f;

-            Vector3 ofs = position + half_extents;

-

-            return ofs + new Vector3(

-                (dir.x > 0f) ? -half_extents.x : half_extents.x,

-                (dir.y > 0f) ? -half_extents.y : half_extents.y,

-                (dir.z > 0f) ? -half_extents.z : half_extents.z);

-        }

-

-        public Rect3 grow(float by)

-        {

-            Rect3 res = this;

-

-            res.position.x -= by;

-            res.position.y -= by;

-            res.position.z -= by;

-            res.size.x += 2.0f * by;

-            res.size.y += 2.0f * by;

-            res.size.z += 2.0f * by;

-

-            return res;

-        }

-

-        public bool has_no_area()

-        {

-            return size.x <= 0f || size.y <= 0f || size.z <= 0f;

-        }

-

-        public bool has_no_surface()

-        {

-            return size.x <= 0f && size.y <= 0f && size.z <= 0f;

-        }

-

-        public bool has_point(Vector3 point)

-        {

-            if (point.x < position.x)

-                return false;

-            if (point.y < position.y)

-                return false;

-            if (point.z < position.z)

-                return false;

-            if (point.x > position.x + size.x)

-                return false;

-            if (point.y > position.y + size.y)

-                return false;

-            if (point.z > position.z + size.z)

-                return false;

-

-            return true;

-        }

-

-        public Rect3 intersection(Rect3 with)

-        {

-            Vector3 src_min = position;

-            Vector3 src_max = position + size;

-            Vector3 dst_min = with.position;

-            Vector3 dst_max = with.position + with.size;

-

-            Vector3 min, max;

-

-            if (src_min.x > dst_max.x || src_max.x < dst_min.x)

-            {

-                return new Rect3();

-            }

-            else

-            {

-                min.x = (src_min.x > dst_min.x) ? src_min.x : dst_min.x;

-                max.x = (src_max.x < dst_max.x) ? src_max.x : dst_max.x;

-            }

-

-            if (src_min.y > dst_max.y || src_max.y < dst_min.y)

-            {

-                return new Rect3();

-            }

-            else

-            {

-                min.y = (src_min.y > dst_min.y) ? src_min.y : dst_min.y;

-                max.y = (src_max.y < dst_max.y) ? src_max.y : dst_max.y;

-            }

-

-            if (src_min.z > dst_max.z || src_max.z < dst_min.z)

-            {

-                return new Rect3();

-            }

-            else

-            {

-                min.z = (src_min.z > dst_min.z) ? src_min.z : dst_min.z;

-                max.z = (src_max.z < dst_max.z) ? src_max.z : dst_max.z;

-            }

-

-            return new Rect3(min, max - min);

-        }

-

-        public bool intersects(Rect3 with)

-        {

-            if (position.x >= (with.position.x + with.size.x))

-                return false;

-            if ((position.x + size.x) <= with.position.x)

-                return false;

-            if (position.y >= (with.position.y + with.size.y))

-                return false;

-            if ((position.y + size.y) <= with.position.y)

-                return false;

-            if (position.z >= (with.position.z + with.size.z))

-                return false;

-            if ((position.z + size.z) <= with.position.z)

-                return false;

-

-            return true;

-        }

-

-        public bool intersects_plane(Plane plane)

-        {

-            Vector3[] points =

-            {

-                new Vector3(position.x, position.y, position.z),

-                new Vector3(position.x, position.y, position.z + size.z),

-                new Vector3(position.x, position.y + size.y, position.z),

-                new Vector3(position.x, position.y + size.y, position.z + size.z),

-                new Vector3(position.x + size.x, position.y, position.z),

-                new Vector3(position.x + size.x, position.y, position.z + size.z),

-                new Vector3(position.x + size.x, position.y + size.y, position.z),

-                new Vector3(position.x + size.x, position.y + size.y, position.z + size.z),

-            };

-

-            bool over = false;

-            bool under = false;

-

-            for (int i = 0; i < 8; i++)

-            {

-                if (plane.distance_to(points[i]) > 0)

-                    over = true;

-                else

-                    under = true;

-            }

-

-            return under && over;

-        }

-

-        public bool intersects_segment(Vector3 from, Vector3 to)

-        {

-            float min = 0f;

-            float max = 1f;

-

-            for (int i = 0; i < 3; i++)

-            {

-                float seg_from = from[i];

-                float seg_to = to[i];

-                float box_begin = position[i];

-                float box_end = box_begin + size[i];

-                float cmin, cmax;

-

-                if (seg_from < seg_to)

-                {

-                    if (seg_from > box_end || seg_to < box_begin)

-                        return false;

-

-                    float length = seg_to - seg_from;

-                    cmin = seg_from < box_begin ? (box_begin - seg_from) / length : 0f;

-                    cmax = seg_to > box_end ? (box_end - seg_from) / length : 1f;

-                }

-                else

-                {

-                    if (seg_to > box_end || seg_from < box_begin)

-                        return false;

-

-                    float length = seg_to - seg_from;

-                    cmin = seg_from > box_end ? (box_end - seg_from) / length : 0f;

-                    cmax = seg_to < box_begin ? (box_begin - seg_from) / length : 1f;

-                }

-

-                if (cmin > min)

-                {

-                    min = cmin;

-                }

-

-                if (cmax < max)

-                    max = cmax;

-                if (max < min)

-                    return false;

-            }

-

-            return true;

-        }

-

-        public Rect3 merge(Rect3 with)

-        {

-            Vector3 beg_1 = position;

-            Vector3 beg_2 = with.position;

-            Vector3 end_1 = new Vector3(size.x, size.y, size.z) + beg_1;

-            Vector3 end_2 = new Vector3(with.size.x, with.size.y, with.size.z) + beg_2;

-

-            Vector3 min = new Vector3(

-                              (beg_1.x < beg_2.x) ? beg_1.x : beg_2.x,

-                              (beg_1.y < beg_2.y) ? beg_1.y : beg_2.y,

-                              (beg_1.z < beg_2.z) ? beg_1.z : beg_2.z

-                          );

-

-            Vector3 max = new Vector3(

-                              (end_1.x > end_2.x) ? end_1.x : end_2.x,

-                              (end_1.y > end_2.y) ? end_1.y : end_2.y,

-                              (end_1.z > end_2.z) ? end_1.z : end_2.z

-                          );

-

-            return new Rect3(min, max - min);

-        }

-

-        public Rect3(Vector3 position, Vector3 size)

-        {

-            this.position = position;

-            this.size = size;

-        }

-

-        public static bool operator ==(Rect3 left, Rect3 right)

-        {

-            return left.Equals(right);

-        }

-

-        public static bool operator !=(Rect3 left, Rect3 right)

-        {

-            return !left.Equals(right);

-        }

-

-        public override bool Equals(object obj)

-        {

-            if (obj is Rect3)

-            {

-                return Equals((Rect3)obj);

-            }

-

-            return false;

-        }

-

-        public bool Equals(Rect3 other)

-        {

-            return position == other.position && size == other.size;

-        }

-

-        public override int GetHashCode()

-        {

-            return position.GetHashCode() ^ size.GetHashCode();

-        }

-

-        public override string ToString()

-        {

-            return String.Format("{0} - {1}", new object[]

-                {

-                    this.position.ToString(),

-                    this.size.ToString()

-                });

-        }

-

-        public string ToString(string format)

-        {

-            return String.Format("{0} - {1}", new object[]

-                {

-                    this.position.ToString(format),

-                    this.size.ToString(format)

-                });

-        }

-    }

-}

+using System;
+
+// file: core/math/rect3.h
+// commit: 7ad14e7a3e6f87ddc450f7e34621eb5200808451
+// file: core/math/rect3.cpp
+// commit: bd282ff43f23fe845f29a3e25c8efc01bd65ffb0
+// file: core/variant_call.cpp
+// commit: 5ad9be4c24e9d7dc5672fdc42cea896622fe5685
+
+namespace Godot
+{
+    public struct Rect3 : IEquatable<Rect3>
+    {
+        private Vector3 position;
+        private Vector3 size;
+
+        public Vector3 Position
+        {
+            get
+            {
+                return position;
+            }
+        }
+
+        public Vector3 Size
+        {
+            get
+            {
+                return size;
+            }
+        }
+
+        public Vector3 End
+        {
+            get
+            {
+                return position + size;
+            }
+        }
+
+        public bool encloses(Rect3 with)
+        {
+            Vector3 src_min = position;
+            Vector3 src_max = position + size;
+            Vector3 dst_min = with.position;
+            Vector3 dst_max = with.position + with.size;
+
+            return ((src_min.x <= dst_min.x) &&
+                    (src_max.x > dst_max.x) &&
+                    (src_min.y <= dst_min.y) &&
+                    (src_max.y > dst_max.y) &&
+                    (src_min.z <= dst_min.z) &&
+                    (src_max.z > dst_max.z));
+        }
+
+        public Rect3 expand(Vector3 to_point)
+        {
+            Vector3 begin = position;
+            Vector3 end = position + size;
+
+            if (to_point.x < begin.x)
+                begin.x = to_point.x;
+            if (to_point.y < begin.y)
+                begin.y = to_point.y;
+            if (to_point.z < begin.z)
+                begin.z = to_point.z;
+
+            if (to_point.x > end.x)
+                end.x = to_point.x;
+            if (to_point.y > end.y)
+                end.y = to_point.y;
+            if (to_point.z > end.z)
+                end.z = to_point.z;
+
+            return new Rect3(begin, end - begin);
+        }
+
+        public float get_area()
+        {
+            return size.x * size.y * size.z;
+        }
+
+        public Vector3 get_endpoint(int idx)
+        {
+            switch (idx)
+            {
+                case 0:
+                    return new Vector3(position.x, position.y, position.z);
+                case 1:
+                    return new Vector3(position.x, position.y, position.z + size.z);
+                case 2:
+                    return new Vector3(position.x, position.y + size.y, position.z);
+                case 3:
+                    return new Vector3(position.x, position.y + size.y, position.z + size.z);
+                case 4:
+                    return new Vector3(position.x + size.x, position.y, position.z);
+                case 5:
+                    return new Vector3(position.x + size.x, position.y, position.z + size.z);
+                case 6:
+                    return new Vector3(position.x + size.x, position.y + size.y, position.z);
+                case 7:
+                    return new Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(idx), String.Format("Index is {0}, but a value from 0 to 7 is expected.", idx));
+            }
+        }
+
+        public Vector3 get_longest_axis()
+        {
+            Vector3 axis = new Vector3(1f, 0f, 0f);
+            float max_size = size.x;
+
+            if (size.y > max_size)
+            {
+                axis = new Vector3(0f, 1f, 0f);
+                max_size = size.y;
+            }
+
+            if (size.z > max_size)
+            {
+                axis = new Vector3(0f, 0f, 1f);
+                max_size = size.z;
+            }
+
+            return axis;
+        }
+
+        public Vector3.Axis get_longest_axis_index()
+        {
+            Vector3.Axis axis = Vector3.Axis.X;
+            float max_size = size.x;
+
+            if (size.y > max_size)
+            {
+                axis = Vector3.Axis.Y;
+                max_size = size.y;
+            }
+
+            if (size.z > max_size)
+            {
+                axis = Vector3.Axis.Z;
+                max_size = size.z;
+            }
+
+            return axis;
+        }
+
+        public float get_longest_axis_size()
+        {
+            float max_size = size.x;
+
+            if (size.y > max_size)
+                max_size = size.y;
+
+            if (size.z > max_size)
+                max_size = size.z;
+
+            return max_size;
+        }
+
+        public Vector3 get_shortest_axis()
+        {
+            Vector3 axis = new Vector3(1f, 0f, 0f);
+            float max_size = size.x;
+
+            if (size.y < max_size)
+            {
+                axis = new Vector3(0f, 1f, 0f);
+                max_size = size.y;
+            }
+
+            if (size.z < max_size)
+            {
+                axis = new Vector3(0f, 0f, 1f);
+                max_size = size.z;
+            }
+
+            return axis;
+        }
+
+        public Vector3.Axis get_shortest_axis_index()
+        {
+            Vector3.Axis axis = Vector3.Axis.X;
+            float max_size = size.x;
+
+            if (size.y < max_size)
+            {
+                axis = Vector3.Axis.Y;
+                max_size = size.y;
+            }
+
+            if (size.z < max_size)
+            {
+                axis = Vector3.Axis.Z;
+                max_size = size.z;
+            }
+
+            return axis;
+        }
+
+        public float get_shortest_axis_size()
+        {
+            float max_size = size.x;
+
+            if (size.y < max_size)
+                max_size = size.y;
+
+            if (size.z < max_size)
+                max_size = size.z;
+
+            return max_size;
+        }
+
+        public Vector3 get_support(Vector3 dir)
+        {
+            Vector3 half_extents = size * 0.5f;
+            Vector3 ofs = position + half_extents;
+
+            return ofs + new Vector3(
+                (dir.x > 0f) ? -half_extents.x : half_extents.x,
+                (dir.y > 0f) ? -half_extents.y : half_extents.y,
+                (dir.z > 0f) ? -half_extents.z : half_extents.z);
+        }
+
+        public Rect3 grow(float by)
+        {
+            Rect3 res = this;
+
+            res.position.x -= by;
+            res.position.y -= by;
+            res.position.z -= by;
+            res.size.x += 2.0f * by;
+            res.size.y += 2.0f * by;
+            res.size.z += 2.0f * by;
+
+            return res;
+        }
+
+        public bool has_no_area()
+        {
+            return size.x <= 0f || size.y <= 0f || size.z <= 0f;
+        }
+
+        public bool has_no_surface()
+        {
+            return size.x <= 0f && size.y <= 0f && size.z <= 0f;
+        }
+
+        public bool has_point(Vector3 point)
+        {
+            if (point.x < position.x)
+                return false;
+            if (point.y < position.y)
+                return false;
+            if (point.z < position.z)
+                return false;
+            if (point.x > position.x + size.x)
+                return false;
+            if (point.y > position.y + size.y)
+                return false;
+            if (point.z > position.z + size.z)
+                return false;
+
+            return true;
+        }
+
+        public Rect3 intersection(Rect3 with)
+        {
+            Vector3 src_min = position;
+            Vector3 src_max = position + size;
+            Vector3 dst_min = with.position;
+            Vector3 dst_max = with.position + with.size;
+
+            Vector3 min, max;
+
+            if (src_min.x > dst_max.x || src_max.x < dst_min.x)
+            {
+                return new Rect3();
+            }
+            else
+            {
+                min.x = (src_min.x > dst_min.x) ? src_min.x : dst_min.x;
+                max.x = (src_max.x < dst_max.x) ? src_max.x : dst_max.x;
+            }
+
+            if (src_min.y > dst_max.y || src_max.y < dst_min.y)
+            {
+                return new Rect3();
+            }
+            else
+            {
+                min.y = (src_min.y > dst_min.y) ? src_min.y : dst_min.y;
+                max.y = (src_max.y < dst_max.y) ? src_max.y : dst_max.y;
+            }
+
+            if (src_min.z > dst_max.z || src_max.z < dst_min.z)
+            {
+                return new Rect3();
+            }
+            else
+            {
+                min.z = (src_min.z > dst_min.z) ? src_min.z : dst_min.z;
+                max.z = (src_max.z < dst_max.z) ? src_max.z : dst_max.z;
+            }
+
+            return new Rect3(min, max - min);
+        }
+
+        public bool intersects(Rect3 with)
+        {
+            if (position.x >= (with.position.x + with.size.x))
+                return false;
+            if ((position.x + size.x) <= with.position.x)
+                return false;
+            if (position.y >= (with.position.y + with.size.y))
+                return false;
+            if ((position.y + size.y) <= with.position.y)
+                return false;
+            if (position.z >= (with.position.z + with.size.z))
+                return false;
+            if ((position.z + size.z) <= with.position.z)
+                return false;
+
+            return true;
+        }
+
+        public bool intersects_plane(Plane plane)
+        {
+            Vector3[] points =
+            {
+                new Vector3(position.x, position.y, position.z),
+                new Vector3(position.x, position.y, position.z + size.z),
+                new Vector3(position.x, position.y + size.y, position.z),
+                new Vector3(position.x, position.y + size.y, position.z + size.z),
+                new Vector3(position.x + size.x, position.y, position.z),
+                new Vector3(position.x + size.x, position.y, position.z + size.z),
+                new Vector3(position.x + size.x, position.y + size.y, position.z),
+                new Vector3(position.x + size.x, position.y + size.y, position.z + size.z),
+            };
+
+            bool over = false;
+            bool under = false;
+
+            for (int i = 0; i < 8; i++)
+            {
+                if (plane.distance_to(points[i]) > 0)
+                    over = true;
+                else
+                    under = true;
+            }
+
+            return under && over;
+        }
+
+        public bool intersects_segment(Vector3 from, Vector3 to)
+        {
+            float min = 0f;
+            float max = 1f;
+
+            for (int i = 0; i < 3; i++)
+            {
+                float seg_from = from[i];
+                float seg_to = to[i];
+                float box_begin = position[i];
+                float box_end = box_begin + size[i];
+                float cmin, cmax;
+
+                if (seg_from < seg_to)
+                {
+                    if (seg_from > box_end || seg_to < box_begin)
+                        return false;
+
+                    float length = seg_to - seg_from;
+                    cmin = seg_from < box_begin ? (box_begin - seg_from) / length : 0f;
+                    cmax = seg_to > box_end ? (box_end - seg_from) / length : 1f;
+                }
+                else
+                {
+                    if (seg_to > box_end || seg_from < box_begin)
+                        return false;
+
+                    float length = seg_to - seg_from;
+                    cmin = seg_from > box_end ? (box_end - seg_from) / length : 0f;
+                    cmax = seg_to < box_begin ? (box_begin - seg_from) / length : 1f;
+                }
+
+                if (cmin > min)
+                {
+                    min = cmin;
+                }
+
+                if (cmax < max)
+                    max = cmax;
+                if (max < min)
+                    return false;
+            }
+
+            return true;
+        }
+
+        public Rect3 merge(Rect3 with)
+        {
+            Vector3 beg_1 = position;
+            Vector3 beg_2 = with.position;
+            Vector3 end_1 = new Vector3(size.x, size.y, size.z) + beg_1;
+            Vector3 end_2 = new Vector3(with.size.x, with.size.y, with.size.z) + beg_2;
+
+            Vector3 min = new Vector3(
+                              (beg_1.x < beg_2.x) ? beg_1.x : beg_2.x,
+                              (beg_1.y < beg_2.y) ? beg_1.y : beg_2.y,
+                              (beg_1.z < beg_2.z) ? beg_1.z : beg_2.z
+                          );
+
+            Vector3 max = new Vector3(
+                              (end_1.x > end_2.x) ? end_1.x : end_2.x,
+                              (end_1.y > end_2.y) ? end_1.y : end_2.y,
+                              (end_1.z > end_2.z) ? end_1.z : end_2.z
+                          );
+
+            return new Rect3(min, max - min);
+        }
+
+        public Rect3(Vector3 position, Vector3 size)
+        {
+            this.position = position;
+            this.size = size;
+        }
+
+        public static bool operator ==(Rect3 left, Rect3 right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(Rect3 left, Rect3 right)
+        {
+            return !left.Equals(right);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is Rect3)
+            {
+                return Equals((Rect3)obj);
+            }
+
+            return false;
+        }
+
+        public bool Equals(Rect3 other)
+        {
+            return position == other.position && size == other.size;
+        }
+
+        public override int GetHashCode()
+        {
+            return position.GetHashCode() ^ size.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return String.Format("{0} - {1}", new object[]
+                {
+                    this.position.ToString(),
+                    this.size.ToString()
+                });
+        }
+
+        public string ToString(string format)
+        {
+            return String.Format("{0} - {1}", new object[]
+                {
+                    this.position.ToString(format),
+                    this.size.ToString(format)
+                });
+        }
+    }
+}
diff --git a/modules/mono/glue/cs_files/ToolAttribute.cs b/modules/mono/glue/cs_files/ToolAttribute.cs
index 0275982c7f..d8601b5b32 100644
--- a/modules/mono/glue/cs_files/ToolAttribute.cs
+++ b/modules/mono/glue/cs_files/ToolAttribute.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace Godot
 {