Rename Transform to Transform3D in core

6 files changed, 55 insertions, 55 deletions

diff --git a/modules/mono/editor/bindings_generator.cpp b/modules/mono/editor/bindings_generator.cpp
index b48e5df9eb..d4b04408ba 100644
--- a/modules/mono/editor/bindings_generator.cpp
+++ b/modules/mono/editor/bindings_generator.cpp
@@ -3124,8 +3124,8 @@ bool BindingsGenerator::_arg_default_value_from_variant(const Variant &p_val, Ar
 			r_iarg.def_param_mode = ArgumentInterface::NULLABLE_VAL;
 		} break;
 		case Variant::TRANSFORM: {
-			Transform transform = p_val.operator Transform();
-			if (transform == Transform()) {
+			Transform3D transform = p_val.operator Transform3D();
+			if (transform == Transform3D()) {
 				r_iarg.default_argument = "Transform.Identity";
 			} else {
 				Basis basis = transform.basis;
@@ -3197,7 +3197,7 @@ void BindingsGenerator::_populate_builtin_type_interfaces() {
 	INSERT_STRUCT_TYPE(Vector3i)
 	INSERT_STRUCT_TYPE(Basis)
 	INSERT_STRUCT_TYPE(Quat)
-	INSERT_STRUCT_TYPE(Transform)
+	INSERT_STRUCT_TYPE(Transform3D)
 	INSERT_STRUCT_TYPE(AABB)
 	INSERT_STRUCT_TYPE(Color)
 	INSERT_STRUCT_TYPE(Plane)
diff --git a/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform.cs b/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform.cs
index ac47f6029f..9e5ff2b315 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform.cs
@@ -19,7 +19,7 @@ namespace Godot
     /// </summary>
     [Serializable]
     [StructLayout(LayoutKind.Sequential)]
-    public struct Transform : IEquatable<Transform>
+    public struct Transform3D : IEquatable<Transform3D>
     {
         /// <summary>
         /// The <see cref="Basis"/> of this transform. Contains the X, Y, and Z basis
@@ -107,10 +107,10 @@ namespace Godot
         /// the transformation is composed of rotation, scaling, and translation.
         /// </summary>
         /// <returns>The inverse transformation matrix.</returns>
-        public Transform AffineInverse()
+        public Transform3D AffineInverse()
         {
             Basis basisInv = basis.Inverse();
-            return new Transform(basisInv, basisInv.Xform(-origin));
+            return new Transform3D(basisInv, basisInv.Xform(-origin));
         }
 
         /// <summary>
@@ -119,7 +119,7 @@ namespace Godot
         /// <param name="transform">The other transform.</param>
         /// <param name="weight">A value on the range of 0.0 to 1.0, representing the amount of interpolation.</param>
         /// <returns>The interpolated transform.</returns>
-        public Transform InterpolateWith(Transform transform, real_t weight)
+        public Transform3D InterpolateWith(Transform3D transform, real_t weight)
         {
             /* not sure if very "efficient" but good enough? */
 
@@ -131,7 +131,7 @@ namespace Godot
             Quat destinationRotation = transform.basis.RotationQuat();
             Vector3 destinationLocation = transform.origin;
 
-            var interpolated = new Transform();
+            var interpolated = new Transform3D();
             interpolated.basis.SetQuatScale(sourceRotation.Slerp(destinationRotation, weight).Normalized(), sourceScale.Lerp(destinationScale, weight));
             interpolated.origin = sourceLocation.Lerp(destinationLocation, weight);
 
@@ -144,10 +144,10 @@ namespace Godot
         /// (no scaling, use <see cref="AffineInverse"/> for transforms with scaling).
         /// </summary>
         /// <returns>The inverse matrix.</returns>
-        public Transform Inverse()
+        public Transform3D Inverse()
         {
             Basis basisTr = basis.Transposed();
-            return new Transform(basisTr, basisTr.Xform(-origin));
+            return new Transform3D(basisTr, basisTr.Xform(-origin));
         }
 
         /// <summary>
@@ -163,7 +163,7 @@ namespace Godot
         /// <param name="target">The object to look at.</param>
         /// <param name="up">The relative up direction</param>
         /// <returns>The resulting transform.</returns>
-        public Transform LookingAt(Vector3 target, Vector3 up)
+        public Transform3D LookingAt(Vector3 target, Vector3 up)
         {
             var t = this;
             t.SetLookAt(origin, target, up);
@@ -175,9 +175,9 @@ namespace Godot
         /// and normalized axis vectors (scale of 1 or -1).
         /// </summary>
         /// <returns>The orthonormalized transform.</returns>
-        public Transform Orthonormalized()
+        public Transform3D Orthonormalized()
         {
-            return new Transform(basis.Orthonormalized(), origin);
+            return new Transform3D(basis.Orthonormalized(), origin);
         }
 
         /// <summary>
@@ -187,9 +187,9 @@ namespace Godot
         /// <param name="axis">The axis to rotate around. Must be normalized.</param>
         /// <param name="phi">The angle to rotate, in radians.</param>
         /// <returns>The rotated transformation matrix.</returns>
-        public Transform Rotated(Vector3 axis, real_t phi)
+        public Transform3D Rotated(Vector3 axis, real_t phi)
         {
-            return new Transform(new Basis(axis, phi), new Vector3()) * this;
+            return new Transform3D(new Basis(axis, phi), new Vector3()) * this;
         }
 
         /// <summary>
@@ -197,9 +197,9 @@ namespace Godot
         /// </summary>
         /// <param name="scale">The scale to introduce.</param>
         /// <returns>The scaled transformation matrix.</returns>
-        public Transform Scaled(Vector3 scale)
+        public Transform3D Scaled(Vector3 scale)
         {
-            return new Transform(basis.Scaled(scale), origin * scale);
+            return new Transform3D(basis.Scaled(scale), origin * scale);
         }
 
         private void SetLookAt(Vector3 eye, Vector3 target, Vector3 up)
@@ -234,9 +234,9 @@ namespace Godot
         /// </summary>
         /// <param name="offset">The offset to translate by.</param>
         /// <returns>The translated matrix.</returns>
-        public Transform Translated(Vector3 offset)
+        public Transform3D Translated(Vector3 offset)
         {
-            return new Transform(basis, new Vector3
+            return new Transform3D(basis, new Vector3
             (
                 origin[0] += basis.Row0.Dot(offset),
                 origin[1] += basis.Row1.Dot(offset),
@@ -280,10 +280,10 @@ namespace Godot
         }
 
         // Constants
-        private static readonly Transform _identity = new Transform(Basis.Identity, Vector3.Zero);
-        private static readonly Transform _flipX = new Transform(new Basis(-1, 0, 0, 0, 1, 0, 0, 0, 1), Vector3.Zero);
-        private static readonly Transform _flipY = new Transform(new Basis(1, 0, 0, 0, -1, 0, 0, 0, 1), Vector3.Zero);
-        private static readonly Transform _flipZ = new Transform(new Basis(1, 0, 0, 0, 1, 0, 0, 0, -1), Vector3.Zero);
+        private static readonly Transform3D _identity = new Transform3D(Basis.Identity, Vector3.Zero);
+        private static readonly Transform3D _flipX = new Transform3D(new Basis(-1, 0, 0, 0, 1, 0, 0, 0, 1), Vector3.Zero);
+        private static readonly Transform3D _flipY = new Transform3D(new Basis(1, 0, 0, 0, -1, 0, 0, 0, 1), Vector3.Zero);
+        private static readonly Transform3D _flipZ = new Transform3D(new Basis(1, 0, 0, 0, 1, 0, 0, 0, -1), Vector3.Zero);
 
         /// <summary>
         /// The identity transform, with no translation, rotation, or scaling applied.
@@ -291,22 +291,22 @@ namespace Godot
         /// Do not use `new Transform()` with no arguments in C#, because it sets all values to zero.
         /// </summary>
         /// <value>Equivalent to `new Transform(Vector3.Right, Vector3.Up, Vector3.Back, Vector3.Zero)`.</value>
-        public static Transform Identity { get { return _identity; } }
+        public static Transform3D Identity { get { return _identity; } }
         /// <summary>
         /// The transform that will flip something along the X axis.
         /// </summary>
         /// <value>Equivalent to `new Transform(Vector3.Left, Vector3.Up, Vector3.Back, Vector3.Zero)`.</value>
-        public static Transform FlipX { get { return _flipX; } }
+        public static Transform3D FlipX { get { return _flipX; } }
         /// <summary>
         /// The transform that will flip something along the Y axis.
         /// </summary>
         /// <value>Equivalent to `new Transform(Vector3.Right, Vector3.Down, Vector3.Back, Vector3.Zero)`.</value>
-        public static Transform FlipY { get { return _flipY; } }
+        public static Transform3D FlipY { get { return _flipY; } }
         /// <summary>
         /// The transform that will flip something along the Z axis.
         /// </summary>
         /// <value>Equivalent to `new Transform(Vector3.Right, Vector3.Up, Vector3.Forward, Vector3.Zero)`.</value>
-        public static Transform FlipZ { get { return _flipZ; } }
+        public static Transform3D FlipZ { get { return _flipZ; } }
 
         /// <summary>
         /// Constructs a transformation matrix from 4 vectors (matrix columns).
@@ -315,7 +315,7 @@ namespace Godot
         /// <param name="column1">The Y vector, or column index 1.</param>
         /// <param name="column2">The Z vector, or column index 2.</param>
         /// <param name="origin">The origin vector, or column index 3.</param>
-        public Transform(Vector3 column0, Vector3 column1, Vector3 column2, Vector3 origin)
+        public Transform3D(Vector3 column0, Vector3 column1, Vector3 column2, Vector3 origin)
         {
             basis = new Basis(column0, column1, column2);
             this.origin = origin;
@@ -326,7 +326,7 @@ namespace Godot
         /// </summary>
         /// <param name="quat">The <see cref="Godot.Quat"/> to create the basis from.</param>
         /// <param name="origin">The origin vector, or column index 3.</param>
-        public Transform(Quat quat, Vector3 origin)
+        public Transform3D(Quat quat, Vector3 origin)
         {
             basis = new Basis(quat);
             this.origin = origin;
@@ -337,40 +337,40 @@ namespace Godot
         /// </summary>
         /// <param name="basis">The <see cref="Godot.Basis"/> to create the basis from.</param>
         /// <param name="origin">The origin vector, or column index 3.</param>
-        public Transform(Basis basis, Vector3 origin)
+        public Transform3D(Basis basis, Vector3 origin)
         {
             this.basis = basis;
             this.origin = origin;
         }
 
-        public static Transform operator *(Transform left, Transform right)
+        public static Transform3D operator *(Transform3D left, Transform3D right)
         {
             left.origin = left.Xform(right.origin);
             left.basis *= right.basis;
             return left;
         }
 
-        public static bool operator ==(Transform left, Transform right)
+        public static bool operator ==(Transform3D left, Transform3D right)
         {
             return left.Equals(right);
         }
 
-        public static bool operator !=(Transform left, Transform right)
+        public static bool operator !=(Transform3D left, Transform3D right)
         {
             return !left.Equals(right);
         }
 
         public override bool Equals(object obj)
         {
-            if (obj is Transform)
+            if (obj is Transform3D)
             {
-                return Equals((Transform)obj);
+                return Equals((Transform3D)obj);
             }
 
             return false;
         }
 
-        public bool Equals(Transform other)
+        public bool Equals(Transform3D other)
         {
             return basis.Equals(other.basis) && origin.Equals(other.origin);
         }
@@ -381,7 +381,7 @@ namespace Godot
         /// </summary>
         /// <param name="other">The other transform to compare.</param>
         /// <returns>Whether or not the matrices are approximately equal.</returns>
-        public bool IsEqualApprox(Transform other)
+        public bool IsEqualApprox(Transform3D other)
         {
             return basis.IsEqualApprox(other.basis) && origin.IsEqualApprox(other.origin);
         }
diff --git a/modules/mono/mono_gd/gd_mono_cache.cpp b/modules/mono/mono_gd/gd_mono_cache.cpp
index d66cc29b9a..adb0518cd6 100644
--- a/modules/mono/mono_gd/gd_mono_cache.cpp
+++ b/modules/mono/mono_gd/gd_mono_cache.cpp
@@ -110,7 +110,7 @@ void CachedData::clear_godot_api_cache() {
 	class_Vector3i = nullptr;
 	class_Basis = nullptr;
 	class_Quat = nullptr;
-	class_Transform = nullptr;
+	class_Transform3D = nullptr;
 	class_AABB = nullptr;
 	class_Color = nullptr;
 	class_Plane = nullptr;
@@ -239,7 +239,7 @@ void update_godot_api_cache() {
 	CACHE_CLASS_AND_CHECK(Vector3i, GODOT_API_CLASS(Vector3i));
 	CACHE_CLASS_AND_CHECK(Basis, GODOT_API_CLASS(Basis));
 	CACHE_CLASS_AND_CHECK(Quat, GODOT_API_CLASS(Quat));
-	CACHE_CLASS_AND_CHECK(Transform, GODOT_API_CLASS(Transform));
+	CACHE_CLASS_AND_CHECK(Transform3D, GODOT_API_CLASS(Transform3D));
 	CACHE_CLASS_AND_CHECK(AABB, GODOT_API_CLASS(AABB));
 	CACHE_CLASS_AND_CHECK(Color, GODOT_API_CLASS(Color));
 	CACHE_CLASS_AND_CHECK(Plane, GODOT_API_CLASS(Plane));
diff --git a/modules/mono/mono_gd/gd_mono_field.cpp b/modules/mono/mono_gd/gd_mono_field.cpp
index 1d4d52dfce..4bbecc2062 100644
--- a/modules/mono/mono_gd/gd_mono_field.cpp
+++ b/modules/mono/mono_gd/gd_mono_field.cpp
@@ -152,8 +152,8 @@ void GDMonoField::set_value_from_variant(MonoObject *p_object, const Variant &p_
 				break;
 			}
 
-			if (tclass == CACHED_CLASS(Transform)) {
-				GDMonoMarshal::M_Transform from = MARSHALLED_OUT(Transform, p_value.operator ::Transform());
+			if (tclass == CACHED_CLASS(Transform3D)) {
+				GDMonoMarshal::M_Transform from = MARSHALLED_OUT(Transform3D, p_value.operator ::Transform3D());
 				mono_field_set_value(p_object, mono_field, &from);
 				break;
 			}
@@ -349,7 +349,7 @@ void GDMonoField::set_value_from_variant(MonoObject *p_object, const Variant &p_
 					mono_field_set_value(p_object, mono_field, &from);
 				} break;
 				case Variant::TRANSFORM: {
-					GDMonoMarshal::M_Transform from = MARSHALLED_OUT(Transform, p_value.operator ::Transform());
+					GDMonoMarshal::M_Transform from = MARSHALLED_OUT(Transform3D, p_value.operator ::Transform3D());
 					mono_field_set_value(p_object, mono_field, &from);
 				} break;
 				case Variant::COLOR: {
diff --git a/modules/mono/mono_gd/gd_mono_marshal.cpp b/modules/mono/mono_gd/gd_mono_marshal.cpp
index 359f6bba4d..03715315b4 100644
--- a/modules/mono/mono_gd/gd_mono_marshal.cpp
+++ b/modules/mono/mono_gd/gd_mono_marshal.cpp
@@ -108,7 +108,7 @@ Variant::Type managed_to_variant_type(const ManagedType &p_type, bool *r_nil_is_
 				return Variant::QUAT;
 			}
 
-			if (vtclass == CACHED_CLASS(Transform)) {
+			if (vtclass == CACHED_CLASS(Transform3D)) {
 				return Variant::TRANSFORM;
 			}
 
@@ -1040,8 +1040,8 @@ Variant mono_object_to_variant_impl(MonoObject *p_obj, const ManagedType &p_type
 				return MARSHALLED_IN(Quat, unbox_addr<GDMonoMarshal::M_Quat>(p_obj));
 			}
 
-			if (vtclass == CACHED_CLASS(Transform)) {
-				return MARSHALLED_IN(Transform, unbox_addr<GDMonoMarshal::M_Transform>(p_obj));
+			if (vtclass == CACHED_CLASS(Transform3D)) {
+				return MARSHALLED_IN(Transform3D, unbox_addr<GDMonoMarshal::M_Transform3D>(p_obj));
 			}
 
 			if (vtclass == CACHED_CLASS(AABB)) {
diff --git a/modules/mono/mono_gd/gd_mono_marshal.h b/modules/mono/mono_gd/gd_mono_marshal.h
index 668809ae5d..141d6a66bd 100644
--- a/modules/mono/mono_gd/gd_mono_marshal.h
+++ b/modules/mono/mono_gd/gd_mono_marshal.h
@@ -269,9 +269,9 @@ enum {
 					offsetof(Quat, z) == (sizeof(real_t) * 2) &&
 					offsetof(Quat, w) == (sizeof(real_t) * 3)),
 
-	MATCHES_Transform = (MATCHES_Basis && MATCHES_Vector3 && (sizeof(Transform) == (sizeof(Basis) + sizeof(Vector3))) &&
-						 offsetof(Transform, basis) == 0 &&
-						 offsetof(Transform, origin) == sizeof(Basis)),
+	MATCHES_Transform3D = (MATCHES_Basis && MATCHES_Vector3 && (sizeof(Transform3D) == (sizeof(Basis) + sizeof(Vector3))) &&
+						   offsetof(Transform3D, basis) == 0 &&
+						   offsetof(Transform3D, origin) == sizeof(Basis)),
 
 	MATCHES_AABB = (MATCHES_Vector3 && (sizeof(AABB) == (sizeof(Vector3) * 2)) &&
 					offsetof(AABB, position) == (sizeof(Vector3) * 0) &&
@@ -292,7 +292,7 @@ enum {
 #ifdef GD_MONO_FORCE_INTEROP_STRUCT_COPY
 /* clang-format off */
 static_assert(MATCHES_Vector2 && MATCHES_Rect2 && MATCHES_Transform2D && MATCHES_Vector3 &&
-				MATCHES_Basis && MATCHES_Quat && MATCHES_Transform && MATCHES_AABB && MATCHES_Color &&
+				MATCHES_Basis && MATCHES_Quat && MATCHES_Transform3D && MATCHES_AABB && MATCHES_Color &&
 				MATCHES_Plane && MATCHES_Vector2i && MATCHES_Rect2i && MATCHES_Vector3i);
 /* clang-format on */
 #endif
@@ -433,16 +433,16 @@ struct M_Quat {
 	}
 };
 
-struct M_Transform {
+struct M_Transform3D {
 	M_Basis basis;
 	M_Vector3 origin;
 
-	static _FORCE_INLINE_ Transform convert_to(const M_Transform &p_from) {
-		return Transform(M_Basis::convert_to(p_from.basis), M_Vector3::convert_to(p_from.origin));
+	static _FORCE_INLINE_ Transform3D convert_to(const M_Transform3D &p_from) {
+		return Transform3D(M_Basis::convert_to(p_from.basis), M_Vector3::convert_to(p_from.origin));
 	}
 
-	static _FORCE_INLINE_ M_Transform convert_from(const Transform &p_from) {
-		M_Transform ret = { M_Basis::convert_from(p_from.basis), M_Vector3::convert_from(p_from.origin) };
+	static _FORCE_INLINE_ M_Transform3D convert_from(const Transform3D &p_from) {
+		M_Transform3D ret = { M_Basis::convert_from(p_from.basis), M_Vector3::convert_from(p_from.origin) };
 		return ret;
 	}
 };
@@ -534,7 +534,7 @@ DECL_TYPE_MARSHAL_TEMPLATES(Vector3)
 DECL_TYPE_MARSHAL_TEMPLATES(Vector3i)
 DECL_TYPE_MARSHAL_TEMPLATES(Basis)
 DECL_TYPE_MARSHAL_TEMPLATES(Quat)
-DECL_TYPE_MARSHAL_TEMPLATES(Transform)
+DECL_TYPE_MARSHAL_TEMPLATES(Transform3D)
 DECL_TYPE_MARSHAL_TEMPLATES(AABB)
 DECL_TYPE_MARSHAL_TEMPLATES(Color)
 DECL_TYPE_MARSHAL_TEMPLATES(Plane)