Merge pull request #64367 from Mickeon/rename-var-to-str

Rename `str2var` to `str_to_var` and similar

6 files changed, 45 insertions, 45 deletions

diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/DelegateUtils.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/DelegateUtils.cs
index 266038a0af..3c75d18943 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/DelegateUtils.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/DelegateUtils.cs
@@ -181,9 +181,9 @@ namespace Godot
                                 if (variantType == Variant.Type.Nil)
                                     return false;
 
-                                static byte[] Var2Bytes(in godot_variant var)
+                                static byte[] VarToBytes(in godot_variant var)
                                 {
-                                    NativeFuncs.godotsharp_var2bytes(var, false.ToGodotBool(), out var varBytes);
+                                    NativeFuncs.godotsharp_var_to_bytes(var, false.ToGodotBool(), out var varBytes);
                                     using (varBytes)
                                         return Marshaling.ConvertNativePackedByteArrayToSystemArray(varBytes);
                                 }
@@ -192,7 +192,7 @@ namespace Godot
 
                                 var fieldValue = field.GetValue(target);
                                 using var fieldValueVariant = Marshaling.ConvertManagedObjectToVariant(fieldValue);
-                                byte[] valueBuffer = Var2Bytes(fieldValueVariant);
+                                byte[] valueBuffer = VarToBytes(fieldValueVariant);
                                 writer.Write(valueBuffer.Length);
                                 writer.Write(valueBuffer);
                             }
@@ -448,7 +448,7 @@ namespace Godot
 
                             FieldInfo? fieldInfo = targetType.GetField(name,
                                 BindingFlags.Instance | BindingFlags.Public);
-                            fieldInfo?.SetValue(recreatedTarget, GD.Bytes2Var(valueBuffer));
+                            fieldInfo?.SetValue(recreatedTarget, GD.BytesToVar(valueBuffer));
                         }
 
                         @delegate = Delegate.CreateDelegate(delegateType, recreatedTarget, methodInfo,
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs
index 9e7da7757a..e4b79e7ec4 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/GD.cs
@@ -21,10 +21,10 @@ namespace Godot
         /// <param name="bytes">Byte array that will be decoded to a <c>Variant</c>.</param>
         /// <param name="allowObjects">If objects should be decoded.</param>
         /// <returns>The decoded <c>Variant</c>.</returns>
-        public static Variant Bytes2Var(Span<byte> bytes, bool allowObjects = false)
+        public static Variant BytesToVar(Span<byte> bytes, bool allowObjects = false)
         {
             using var varBytes = Marshaling.ConvertSystemArrayToNativePackedByteArray(bytes);
-            NativeFuncs.godotsharp_bytes2var(varBytes, allowObjects.ToGodotBool(), out godot_variant ret);
+            NativeFuncs.godotsharp_bytes_to_var(varBytes, allowObjects.ToGodotBool(), out godot_variant ret);
             return Variant.CreateTakingOwnershipOfDisposableValue(ret);
         }
 
@@ -52,10 +52,10 @@ namespace Godot
         /// <summary>
         /// Converts from decibels to linear energy (audio).
         /// </summary>
-        /// <seealso cref="Linear2Db(real_t)"/>
+        /// <seealso cref="LinearToDb(real_t)"/>
         /// <param name="db">Decibels to convert.</param>
         /// <returns>Audio volume as linear energy.</returns>
-        public static real_t Db2Linear(real_t db)
+        public static real_t DbToLinear(real_t db)
         {
             return (real_t)Math.Exp(db * 0.11512925464970228420089957273422);
         }
@@ -115,18 +115,18 @@ namespace Godot
         /// Converts from linear energy to decibels (audio).
         /// This can be used to implement volume sliders that behave as expected (since volume isn't linear).
         /// </summary>
-        /// <seealso cref="Db2Linear(real_t)"/>
+        /// <seealso cref="DbToLinear(real_t)"/>
         /// <example>
         /// <code>
         /// // "slider" refers to a node that inherits Range such as HSlider or VSlider.
         /// // Its range must be configured to go from 0 to 1.
         /// // Change the bus name if you'd like to change the volume of a specific bus only.
-        /// AudioServer.SetBusVolumeDb(AudioServer.GetBusIndex("Master"), GD.Linear2Db(slider.value));
+        /// AudioServer.SetBusVolumeDb(AudioServer.GetBusIndex("Master"), GD.LinearToDb(slider.value));
         /// </code>
         /// </example>
         /// <param name="linear">The linear energy to convert.</param>
         /// <returns>Audio as decibels.</returns>
-        public static real_t Linear2Db(real_t linear)
+        public static real_t LinearToDb(real_t linear)
         {
             return (real_t)(Math.Log(linear) * 8.6858896380650365530225783783321);
         }
@@ -518,21 +518,21 @@ namespace Godot
         }
 
         /// <summary>
-        /// Converts a formatted string that was returned by <see cref="Var2Str(Variant)"/> to the original value.
+        /// Converts a formatted string that was returned by <see cref="VarToStr(Variant)"/> to the original value.
         /// </summary>
         /// <example>
         /// <code>
         /// string a = "{\"a\": 1, \"b\": 2 }";
-        /// var b = (Godot.Collections.Dictionary)GD.Str2Var(a);
+        /// var b = (Godot.Collections.Dictionary)GD.StrToVar(a);
         /// GD.Print(b["a"]); // Prints 1
         /// </code>
         /// </example>
         /// <param name="str">String that will be converted to Variant.</param>
         /// <returns>The decoded <c>Variant</c>.</returns>
-        public static Variant Str2Var(string str)
+        public static Variant StrToVar(string str)
         {
             using var godotStr = Marshaling.ConvertStringToNative(str);
-            NativeFuncs.godotsharp_str2var(godotStr, out godot_variant ret);
+            NativeFuncs.godotsharp_str_to_var(godotStr, out godot_variant ret);
             return Variant.CreateTakingOwnershipOfDisposableValue(ret);
         }
 
@@ -540,26 +540,26 @@ namespace Godot
         /// Encodes a <c>Variant</c> value to a byte array.
         /// If <paramref name="fullObjects"/> is <see langword="true"/> encoding objects is allowed
         /// (and can potentially include code).
-        /// Deserialization can be done with <see cref="Bytes2Var(Span{byte}, bool)"/>.
+        /// Deserialization can be done with <see cref="BytesToVar(Span{byte}, bool)"/>.
         /// </summary>
         /// <param name="var">Variant that will be encoded.</param>
         /// <param name="fullObjects">If objects should be serialized.</param>
         /// <returns>The <c>Variant</c> encoded as an array of bytes.</returns>
-        public static byte[] Var2Bytes(Variant var, bool fullObjects = false)
+        public static byte[] VarToBytes(Variant var, bool fullObjects = false)
         {
-            NativeFuncs.godotsharp_var2bytes((godot_variant)var.NativeVar, fullObjects.ToGodotBool(), out var varBytes);
+            NativeFuncs.godotsharp_var_to_bytes((godot_variant)var.NativeVar, fullObjects.ToGodotBool(), out var varBytes);
             using (varBytes)
                 return Marshaling.ConvertNativePackedByteArrayToSystemArray(varBytes);
         }
 
         /// <summary>
         /// Converts a <c>Variant</c> <paramref name="var"/> to a formatted string that
-        /// can later be parsed using <see cref="Str2Var(string)"/>.
+        /// can later be parsed using <see cref="StrToVar(string)"/>.
         /// </summary>
         /// <example>
         /// <code>
         /// var a = new Godot.Collections.Dictionary { ["a"] = 1, ["b"] = 2 };
-        /// GD.Print(GD.Var2Str(a));
+        /// GD.Print(GD.VarToStr(a));
         /// // Prints
         /// // {
         /// //    "a": 1,
@@ -569,9 +569,9 @@ namespace Godot
         /// </example>
         /// <param name="var">Variant that will be converted to string.</param>
         /// <returns>The <c>Variant</c> encoded as a string.</returns>
-        public static string Var2Str(Variant var)
+        public static string VarToStr(Variant var)
         {
-            NativeFuncs.godotsharp_var2str((godot_variant)var.NativeVar, out godot_string ret);
+            NativeFuncs.godotsharp_var_to_str((godot_variant)var.NativeVar, out godot_string ret);
             using (ret)
                 return Marshaling.ConvertStringToManaged(ret);
         }
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Mathf.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Mathf.cs
index 41a0dd871c..00e775e6ad 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Mathf.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Mathf.cs
@@ -35,9 +35,9 @@ namespace Godot
         public const real_t NaN = real_t.NaN;
 
         // 0.0174532924f and 0.0174532925199433
-        private const real_t _deg2RadConst = (real_t)0.0174532925199432957692369077M;
+        private const real_t _degToRadConst = (real_t)0.0174532925199432957692369077M;
         // 57.29578f and 57.2957795130823
-        private const real_t _rad2DegConst = (real_t)57.295779513082320876798154814M;
+        private const real_t _radToDegConst = (real_t)57.295779513082320876798154814M;
 
         /// <summary>
         /// Returns the absolute value of <paramref name="s"/> (i.e. positive value).
@@ -219,9 +219,9 @@ namespace Godot
         /// </summary>
         /// <param name="deg">An angle expressed in degrees.</param>
         /// <returns>The same angle expressed in radians.</returns>
-        public static real_t Deg2Rad(real_t deg)
+        public static real_t DegToRad(real_t deg)
         {
-            return deg * _deg2RadConst;
+            return deg * _degToRadConst;
         }
 
         /// <summary>
@@ -531,9 +531,9 @@ namespace Godot
         /// </summary>
         /// <param name="rad">An angle expressed in radians.</param>
         /// <returns>The same angle expressed in degrees.</returns>
-        public static real_t Rad2Deg(real_t rad)
+        public static real_t RadToDeg(real_t rad)
         {
-            return rad * _rad2DegConst;
+            return rad * _radToDegConst;
         }
 
         /// <summary>
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/NativeInterop/NativeFuncs.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/NativeInterop/NativeFuncs.cs
index 6d2534e6f7..48c1b48c59 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/NativeInterop/NativeFuncs.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/NativeInterop/NativeFuncs.cs
@@ -461,7 +461,7 @@ namespace Godot.NativeInterop
 
         // GD, etc
 
-        internal static partial void godotsharp_bytes2var(in godot_packed_byte_array p_bytes,
+        internal static partial void godotsharp_bytes_to_var(in godot_packed_byte_array p_bytes,
             godot_bool p_allow_objects,
             out godot_variant r_ret);
 
@@ -504,12 +504,12 @@ namespace Godot.NativeInterop
 
         internal static partial void godotsharp_str(in godot_array p_what, out godot_string r_ret);
 
-        internal static partial void godotsharp_str2var(in godot_string p_str, out godot_variant r_ret);
+        internal static partial void godotsharp_str_to_var(in godot_string p_str, out godot_variant r_ret);
 
-        internal static partial void godotsharp_var2bytes(in godot_variant p_what, godot_bool p_full_objects,
+        internal static partial void godotsharp_var_to_bytes(in godot_variant p_what, godot_bool p_full_objects,
             out godot_packed_byte_array r_bytes);
 
-        internal static partial void godotsharp_var2str(in godot_variant p_var, out godot_string r_ret);
+        internal static partial void godotsharp_var_to_str(in godot_variant p_var, out godot_string r_ret);
 
         internal static partial void godotsharp_pusherror(in godot_string p_str);
 
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Projection.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Projection.cs
index 5da1f3b560..9d08e7120a 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Projection.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Projection.cs
@@ -226,7 +226,7 @@ namespace Godot
             {
                 fovyDegrees = GetFovy(fovyDegrees, (real_t)1.0 / aspect);
             }
-            real_t radians = Mathf.Deg2Rad(fovyDegrees / (real_t)2.0);
+            real_t radians = Mathf.DegToRad(fovyDegrees / (real_t)2.0);
             real_t deltaZ = zFar - zNear;
             real_t sine = Mathf.Sin(radians);
 
@@ -256,7 +256,7 @@ namespace Godot
                 fovyDegrees = GetFovy(fovyDegrees, (real_t)1.0 / aspect);
             }
 
-            real_t ymax = zNear * Mathf.Tan(Mathf.Deg2Rad(fovyDegrees / (real_t)2.0));
+            real_t ymax = zNear * Mathf.Tan(Mathf.DegToRad(fovyDegrees / (real_t)2.0));
             real_t xmax = ymax * aspect;
             real_t frustumshift = (intraocularDist / (real_t)2.0) * zNear / convergenceDist;
             real_t left;
@@ -313,18 +313,18 @@ namespace Godot
             Plane rightPlane = new Plane(x.w - x.x, y.w - y.x, z.w - z.x, -w.w + w.x).Normalized();
             if (z.x == 0 && z.y == 0)
             {
-                return Mathf.Rad2Deg(Mathf.Acos(Mathf.Abs(rightPlane.Normal.x))) * (real_t)2.0;
+                return Mathf.RadToDeg(Mathf.Acos(Mathf.Abs(rightPlane.Normal.x))) * (real_t)2.0;
             }
             else
             {
                 Plane leftPlane = new Plane(x.w + x.x, y.w + y.x, z.w + z.x, w.w + w.x).Normalized();
-                return Mathf.Rad2Deg(Mathf.Acos(Mathf.Abs(leftPlane.Normal.x))) + Mathf.Rad2Deg(Mathf.Acos(Mathf.Abs(rightPlane.Normal.x)));
+                return Mathf.RadToDeg(Mathf.Acos(Mathf.Abs(leftPlane.Normal.x))) + Mathf.RadToDeg(Mathf.Acos(Mathf.Abs(rightPlane.Normal.x)));
             }
         }
 
         public static real_t GetFovy(real_t fovx, real_t aspect)
         {
-            return Mathf.Rad2Deg(Mathf.Atan(aspect * Mathf.Tan(Mathf.Deg2Rad(fovx) * (real_t)0.5)) * (real_t)2.0);
+            return Mathf.RadToDeg(Mathf.Atan(aspect * Mathf.Tan(Mathf.DegToRad(fovx) * (real_t)0.5)) * (real_t)2.0);
         }
 
         public real_t GetLodMultiplier()
diff --git a/modules/mono/glue/runtime_interop.cpp b/modules/mono/glue/runtime_interop.cpp
index 13d4395a64..0d68cb54b9 100644
--- a/modules/mono/glue/runtime_interop.cpp
+++ b/modules/mono/glue/runtime_interop.cpp
@@ -1233,13 +1233,13 @@ void godotsharp_pushwarning(const godot_string *p_str) {
 	WARN_PRINT(*reinterpret_cast<const String *>(p_str));
 }
 
-void godotsharp_var2str(const godot_variant *p_var, godot_string *r_ret) {
+void godotsharp_var_to_str(const godot_variant *p_var, godot_string *r_ret) {
 	const Variant &var = *reinterpret_cast<const Variant *>(p_var);
 	String &vars = *memnew_placement(r_ret, String);
 	VariantWriter::write_to_string(var, vars);
 }
 
-void godotsharp_str2var(const godot_string *p_str, godot_variant *r_ret) {
+void godotsharp_str_to_var(const godot_string *p_str, godot_variant *r_ret) {
 	Variant ret;
 
 	VariantParser::StreamString ss;
@@ -1256,7 +1256,7 @@ void godotsharp_str2var(const godot_string *p_str, godot_variant *r_ret) {
 	memnew_placement(r_ret, Variant(ret));
 }
 
-void godotsharp_var2bytes(const godot_variant *p_var, bool p_full_objects, godot_packed_array *r_bytes) {
+void godotsharp_var_to_bytes(const godot_variant *p_var, bool p_full_objects, godot_packed_array *r_bytes) {
 	const Variant &var = *reinterpret_cast<const Variant *>(p_var);
 	PackedByteArray &bytes = *memnew_placement(r_bytes, PackedByteArray);
 
@@ -1268,7 +1268,7 @@ void godotsharp_var2bytes(const godot_variant *p_var, bool p_full_objects, godot
 	encode_variant(var, bytes.ptrw(), len, p_full_objects);
 }
 
-void godotsharp_bytes2var(const godot_packed_array *p_bytes, bool p_allow_objects, godot_variant *r_ret) {
+void godotsharp_bytes_to_var(const godot_packed_array *p_bytes, bool p_allow_objects, godot_variant *r_ret) {
 	const PackedByteArray *bytes = reinterpret_cast<const PackedByteArray *>(p_bytes);
 	Variant ret;
 	Error err = decode_variant(ret, bytes->ptr(), bytes->size(), nullptr, p_allow_objects);
@@ -1479,7 +1479,7 @@ static const void *unmanaged_callbacks[]{
 	(void *)godotsharp_node_path_get_subname,
 	(void *)godotsharp_node_path_get_subname_count,
 	(void *)godotsharp_node_path_is_absolute,
-	(void *)godotsharp_bytes2var,
+	(void *)godotsharp_bytes_to_var,
 	(void *)godotsharp_convert,
 	(void *)godotsharp_hash,
 	(void *)godotsharp_instance_from_id,
@@ -1499,9 +1499,9 @@ static const void *unmanaged_callbacks[]{
 	(void *)godotsharp_seed,
 	(void *)godotsharp_weakref,
 	(void *)godotsharp_str,
-	(void *)godotsharp_str2var,
-	(void *)godotsharp_var2bytes,
-	(void *)godotsharp_var2str,
+	(void *)godotsharp_str_to_var,
+	(void *)godotsharp_var_to_bytes,
+	(void *)godotsharp_var_to_str,
 	(void *)godotsharp_pusherror,
 	(void *)godotsharp_pushwarning,
 	(void *)godotsharp_object_to_string,