Merge pull request #38430 from aaronfranke/transform3d

86 files changed, 463 insertions, 462 deletions

diff --git a/modules/bullet/bullet_physics_server.cpp b/modules/bullet/bullet_physics_server.cpp
index e601884486..e07be14c5b 100644
--- a/modules/bullet/bullet_physics_server.cpp
+++ b/modules/bullet/bullet_physics_server.cpp
@@ -268,7 +268,7 @@ PhysicsServer3D::AreaSpaceOverrideMode BulletPhysicsServer3D::area_get_space_ove
 	return area->get_spOv_mode();
 }
 
-void BulletPhysicsServer3D::area_add_shape(RID p_area, RID p_shape, const Transform &p_transform, bool p_disabled) {
+void BulletPhysicsServer3D::area_add_shape(RID p_area, RID p_shape, const Transform3D &p_transform, bool p_disabled) {
 	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
@@ -288,7 +288,7 @@ void BulletPhysicsServer3D::area_set_shape(RID p_area, int p_shape_idx, RID p_sh
 	area->set_shape(p_shape_idx, shape);
 }
 
-void BulletPhysicsServer3D::area_set_shape_transform(RID p_area, int p_shape_idx, const Transform &p_transform) {
+void BulletPhysicsServer3D::area_set_shape_transform(RID p_area, int p_shape_idx, const Transform3D &p_transform) {
 	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
@@ -309,9 +309,9 @@ RID BulletPhysicsServer3D::area_get_shape(RID p_area, int p_shape_idx) const {
 	return area->get_shape(p_shape_idx)->get_self();
 }
 
-Transform BulletPhysicsServer3D::area_get_shape_transform(RID p_area, int p_shape_idx) const {
+Transform3D BulletPhysicsServer3D::area_get_shape_transform(RID p_area, int p_shape_idx) const {
 	AreaBullet *area = area_owner.getornull(p_area);
-	ERR_FAIL_COND_V(!area, Transform());
+	ERR_FAIL_COND_V(!area, Transform3D());
 
 	return area->get_shape_transform(p_shape_idx);
 }
@@ -382,15 +382,15 @@ Variant BulletPhysicsServer3D::area_get_param(RID p_area, AreaParameter p_param)
 	}
 }
 
-void BulletPhysicsServer3D::area_set_transform(RID p_area, const Transform &p_transform) {
+void BulletPhysicsServer3D::area_set_transform(RID p_area, const Transform3D &p_transform) {
 	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_transform(p_transform);
 }
 
-Transform BulletPhysicsServer3D::area_get_transform(RID p_area) const {
+Transform3D BulletPhysicsServer3D::area_get_transform(RID p_area) const {
 	AreaBullet *area = area_owner.getornull(p_area);
-	ERR_FAIL_COND_V(!area, Transform());
+	ERR_FAIL_COND_V(!area, Transform3D());
 	return area->get_transform();
 }
 
@@ -484,7 +484,7 @@ PhysicsServer3D::BodyMode BulletPhysicsServer3D::body_get_mode(RID p_body) const
 	return body->get_mode();
 }
 
-void BulletPhysicsServer3D::body_add_shape(RID p_body, RID p_shape, const Transform &p_transform, bool p_disabled) {
+void BulletPhysicsServer3D::body_add_shape(RID p_body, RID p_shape, const Transform3D &p_transform, bool p_disabled) {
 	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
@@ -504,7 +504,7 @@ void BulletPhysicsServer3D::body_set_shape(RID p_body, int p_shape_idx, RID p_sh
 	body->set_shape(p_shape_idx, shape);
 }
 
-void BulletPhysicsServer3D::body_set_shape_transform(RID p_body, int p_shape_idx, const Transform &p_transform) {
+void BulletPhysicsServer3D::body_set_shape_transform(RID p_body, int p_shape_idx, const Transform3D &p_transform) {
 	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
@@ -527,9 +527,9 @@ RID BulletPhysicsServer3D::body_get_shape(RID p_body, int p_shape_idx) const {
 	return shape->get_self();
 }
 
-Transform BulletPhysicsServer3D::body_get_shape_transform(RID p_body, int p_shape_idx) const {
+Transform3D BulletPhysicsServer3D::body_get_shape_transform(RID p_body, int p_shape_idx) const {
 	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
-	ERR_FAIL_COND_V(!body, Transform());
+	ERR_FAIL_COND_V(!body, Transform3D());
 	return body->get_shape_transform(p_shape_idx);
 }
 
@@ -842,7 +842,7 @@ PhysicsDirectBodyState3D *BulletPhysicsServer3D::body_get_direct_state(RID p_bod
 	return BulletPhysicsDirectBodyState3D::get_singleton(body);
 }
 
-bool BulletPhysicsServer3D::body_test_motion(RID p_body, const Transform &p_from, const Vector3 &p_motion, bool p_infinite_inertia, MotionResult *r_result, bool p_exclude_raycast_shapes) {
+bool BulletPhysicsServer3D::body_test_motion(RID p_body, const Transform3D &p_from, const Vector3 &p_motion, bool p_infinite_inertia, MotionResult *r_result, bool p_exclude_raycast_shapes) {
 	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	ERR_FAIL_COND_V(!body->get_space(), false);
@@ -850,7 +850,7 @@ bool BulletPhysicsServer3D::body_test_motion(RID p_body, const Transform &p_from
 	return body->get_space()->test_body_motion(body, p_from, p_motion, p_infinite_inertia, r_result, p_exclude_raycast_shapes);
 }
 
-int BulletPhysicsServer3D::body_test_ray_separation(RID p_body, const Transform &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, SeparationResult *r_results, int p_result_max, real_t p_margin) {
+int BulletPhysicsServer3D::body_test_ray_separation(RID p_body, const Transform3D &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, SeparationResult *r_results, int p_result_max, real_t p_margin) {
 	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	ERR_FAIL_COND_V(!body->get_space(), 0);
@@ -990,7 +990,7 @@ Variant BulletPhysicsServer3D::soft_body_get_state(RID p_body, BodyState p_state
 	return Variant();
 }
 
-void BulletPhysicsServer3D::soft_body_set_transform(RID p_body, const Transform &p_transform) {
+void BulletPhysicsServer3D::soft_body_set_transform(RID p_body, const Transform3D &p_transform) {
 	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
@@ -1205,7 +1205,7 @@ Vector3 BulletPhysicsServer3D::pin_joint_get_local_b(RID p_joint) const {
 	return pin_joint->getPivotInB();
 }
 
-RID BulletPhysicsServer3D::joint_create_hinge(RID p_body_A, const Transform &p_hinge_A, RID p_body_B, const Transform &p_hinge_B) {
+RID BulletPhysicsServer3D::joint_create_hinge(RID p_body_A, const Transform3D &p_hinge_A, RID p_body_B, const Transform3D &p_hinge_B) {
 	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
@@ -1277,7 +1277,7 @@ bool BulletPhysicsServer3D::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_f
 	return hinge_joint->get_flag(p_flag);
 }
 
-RID BulletPhysicsServer3D::joint_create_slider(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) {
+RID BulletPhysicsServer3D::joint_create_slider(RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
 	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
@@ -1313,7 +1313,7 @@ real_t BulletPhysicsServer3D::slider_joint_get_param(RID p_joint, SliderJointPar
 	return slider_joint->get_param(p_param);
 }
 
-RID BulletPhysicsServer3D::joint_create_cone_twist(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) {
+RID BulletPhysicsServer3D::joint_create_cone_twist(RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
 	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
@@ -1347,7 +1347,7 @@ real_t BulletPhysicsServer3D::cone_twist_joint_get_param(RID p_joint, ConeTwistJ
 	return coneTwist_joint->get_param(p_param);
 }
 
-RID BulletPhysicsServer3D::joint_create_generic_6dof(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) {
+RID BulletPhysicsServer3D::joint_create_generic_6dof(RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
 	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
diff --git a/modules/bullet/bullet_physics_server.h b/modules/bullet/bullet_physics_server.h
index de0379c873..6df913ff80 100644
--- a/modules/bullet/bullet_physics_server.h
+++ b/modules/bullet/bullet_physics_server.h
@@ -134,12 +134,12 @@ public:
 	virtual void area_set_space_override_mode(RID p_area, AreaSpaceOverrideMode p_mode) override;
 	virtual AreaSpaceOverrideMode area_get_space_override_mode(RID p_area) const override;
 
-	virtual void area_add_shape(RID p_area, RID p_shape, const Transform &p_transform = Transform(), bool p_disabled = false) override;
+	virtual void area_add_shape(RID p_area, RID p_shape, const Transform3D &p_transform = Transform3D(), bool p_disabled = false) override;
 	virtual void area_set_shape(RID p_area, int p_shape_idx, RID p_shape) override;
-	virtual void area_set_shape_transform(RID p_area, int p_shape_idx, const Transform &p_transform) override;
+	virtual void area_set_shape_transform(RID p_area, int p_shape_idx, const Transform3D &p_transform) override;
 	virtual int area_get_shape_count(RID p_area) const override;
 	virtual RID area_get_shape(RID p_area, int p_shape_idx) const override;
-	virtual Transform area_get_shape_transform(RID p_area, int p_shape_idx) const override;
+	virtual Transform3D area_get_shape_transform(RID p_area, int p_shape_idx) const override;
 	virtual void area_remove_shape(RID p_area, int p_shape_idx) override;
 	virtual void area_clear_shapes(RID p_area) override;
 	virtual void area_set_shape_disabled(RID p_area, int p_shape_idx, bool p_disabled) override;
@@ -153,8 +153,8 @@ public:
 	virtual void area_set_param(RID p_area, AreaParameter p_param, const Variant &p_value) override;
 	virtual Variant area_get_param(RID p_area, AreaParameter p_param) const override;
 
-	virtual void area_set_transform(RID p_area, const Transform &p_transform) override;
-	virtual Transform area_get_transform(RID p_area) const override;
+	virtual void area_set_transform(RID p_area, const Transform3D &p_transform) override;
+	virtual Transform3D area_get_transform(RID p_area) const override;
 
 	virtual void area_set_collision_mask(RID p_area, uint32_t p_mask) override;
 	virtual void area_set_collision_layer(RID p_area, uint32_t p_layer) override;
@@ -174,14 +174,14 @@ public:
 	virtual void body_set_mode(RID p_body, BodyMode p_mode) override;
 	virtual BodyMode body_get_mode(RID p_body) const override;
 
-	virtual void body_add_shape(RID p_body, RID p_shape, const Transform &p_transform = Transform(), bool p_disabled = false) override;
+	virtual void body_add_shape(RID p_body, RID p_shape, const Transform3D &p_transform = Transform3D(), bool p_disabled = false) override;
 	// Not supported, Please remove and add new shape
 	virtual void body_set_shape(RID p_body, int p_shape_idx, RID p_shape) override;
-	virtual void body_set_shape_transform(RID p_body, int p_shape_idx, const Transform &p_transform) override;
+	virtual void body_set_shape_transform(RID p_body, int p_shape_idx, const Transform3D &p_transform) override;
 
 	virtual int body_get_shape_count(RID p_body) const override;
 	virtual RID body_get_shape(RID p_body, int p_shape_idx) const override;
-	virtual Transform body_get_shape_transform(RID p_body, int p_shape_idx) const override;
+	virtual Transform3D body_get_shape_transform(RID p_body, int p_shape_idx) const override;
 
 	virtual void body_set_shape_disabled(RID p_body, int p_shape_idx, bool p_disabled) override;
 
@@ -253,8 +253,8 @@ public:
 	// this function only works on physics process, errors and returns null otherwise
 	virtual PhysicsDirectBodyState3D *body_get_direct_state(RID p_body) override;
 
-	virtual bool body_test_motion(RID p_body, const Transform &p_from, const Vector3 &p_motion, bool p_infinite_inertia, MotionResult *r_result = nullptr, bool p_exclude_raycast_shapes = true) override;
-	virtual int body_test_ray_separation(RID p_body, const Transform &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, SeparationResult *r_results, int p_result_max, real_t p_margin = 0.001) override;
+	virtual bool body_test_motion(RID p_body, const Transform3D &p_from, const Vector3 &p_motion, bool p_infinite_inertia, MotionResult *r_result = nullptr, bool p_exclude_raycast_shapes = true) override;
+	virtual int body_test_ray_separation(RID p_body, const Transform3D &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, SeparationResult *r_results, int p_result_max, real_t p_margin = 0.001) override;
 
 	/* SOFT BODY API */
 
@@ -283,7 +283,7 @@ public:
 	virtual Variant soft_body_get_state(RID p_body, BodyState p_state) const override;
 
 	/// Special function. This function has bad performance
-	virtual void soft_body_set_transform(RID p_body, const Transform &p_transform) override;
+	virtual void soft_body_set_transform(RID p_body, const Transform3D &p_transform) override;
 
 	virtual void soft_body_set_ray_pickable(RID p_body, bool p_enable) override;
 
@@ -333,7 +333,7 @@ public:
 	virtual void pin_joint_set_local_b(RID p_joint, const Vector3 &p_B) override;
 	virtual Vector3 pin_joint_get_local_b(RID p_joint) const override;
 
-	virtual RID joint_create_hinge(RID p_body_A, const Transform &p_hinge_A, RID p_body_B, const Transform &p_hinge_B) override;
+	virtual RID joint_create_hinge(RID p_body_A, const Transform3D &p_hinge_A, RID p_body_B, const Transform3D &p_hinge_B) override;
 	virtual RID joint_create_hinge_simple(RID p_body_A, const Vector3 &p_pivot_A, const Vector3 &p_axis_A, RID p_body_B, const Vector3 &p_pivot_B, const Vector3 &p_axis_B) override;
 
 	virtual void hinge_joint_set_param(RID p_joint, HingeJointParam p_param, real_t p_value) override;
@@ -343,19 +343,19 @@ public:
 	virtual bool hinge_joint_get_flag(RID p_joint, HingeJointFlag p_flag) const override;
 
 	/// Reference frame is A
-	virtual RID joint_create_slider(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) override;
+	virtual RID joint_create_slider(RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) override;
 
 	virtual void slider_joint_set_param(RID p_joint, SliderJointParam p_param, real_t p_value) override;
 	virtual real_t slider_joint_get_param(RID p_joint, SliderJointParam p_param) const override;
 
 	/// Reference frame is A
-	virtual RID joint_create_cone_twist(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) override;
+	virtual RID joint_create_cone_twist(RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) override;
 
 	virtual void cone_twist_joint_set_param(RID p_joint, ConeTwistJointParam p_param, real_t p_value) override;
 	virtual real_t cone_twist_joint_get_param(RID p_joint, ConeTwistJointParam p_param) const override;
 
 	/// Reference frame is A
-	virtual RID joint_create_generic_6dof(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) override;
+	virtual RID joint_create_generic_6dof(RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) override;
 
 	virtual void generic_6dof_joint_set_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param, real_t p_value) override;
 	virtual real_t generic_6dof_joint_get_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param) override;
diff --git a/modules/bullet/bullet_types_converter.cpp b/modules/bullet/bullet_types_converter.cpp
index 19d4816372..01461767bd 100644
--- a/modules/bullet/bullet_types_converter.cpp
+++ b/modules/bullet/bullet_types_converter.cpp
@@ -59,7 +59,7 @@ void INVERT_B_TO_G(btMatrix3x3 const &inVal, Basis &outVal) {
 	INVERT_B_TO_G(inVal[2], outVal[2]);
 }
 
-void B_TO_G(btTransform const &inVal, Transform &outVal) {
+void B_TO_G(btTransform const &inVal, Transform3D &outVal) {
 	B_TO_G(inVal.getBasis(), outVal.basis);
 	B_TO_G(inVal.getOrigin(), outVal.origin);
 }
@@ -89,7 +89,7 @@ void INVERT_G_TO_B(Basis const &inVal, btMatrix3x3 &outVal) {
 	INVERT_G_TO_B(inVal[2], outVal[2]);
 }
 
-void G_TO_B(Transform const &inVal, btTransform &outVal) {
+void G_TO_B(Transform3D const &inVal, btTransform &outVal) {
 	G_TO_B(inVal.basis, outVal.getBasis());
 	G_TO_B(inVal.origin, outVal.getOrigin());
 }
diff --git a/modules/bullet/bullet_types_converter.h b/modules/bullet/bullet_types_converter.h
index ca9b7175dd..e184fe1769 100644
--- a/modules/bullet/bullet_types_converter.h
+++ b/modules/bullet/bullet_types_converter.h
@@ -32,7 +32,7 @@
 #define BULLET_TYPES_CONVERTER_H
 
 #include "core/math/basis.h"
-#include "core/math/transform.h"
+#include "core/math/transform_3d.h"
 #include "core/math/vector3.h"
 #include "core/typedefs.h"
 
@@ -49,14 +49,14 @@ extern void B_TO_G(btVector3 const &inVal, Vector3 &outVal);
 extern void INVERT_B_TO_G(btVector3 const &inVal, Vector3 &outVal);
 extern void B_TO_G(btMatrix3x3 const &inVal, Basis &outVal);
 extern void INVERT_B_TO_G(btMatrix3x3 const &inVal, Basis &outVal);
-extern void B_TO_G(btTransform const &inVal, Transform &outVal);
+extern void B_TO_G(btTransform const &inVal, Transform3D &outVal);
 
 // Godot TO Bullet
 extern void G_TO_B(Vector3 const &inVal, btVector3 &outVal);
 extern void INVERT_G_TO_B(Vector3 const &inVal, btVector3 &outVal);
 extern void G_TO_B(Basis const &inVal, btMatrix3x3 &outVal);
 extern void INVERT_G_TO_B(Basis const &inVal, btMatrix3x3 &outVal);
-extern void G_TO_B(Transform const &inVal, btTransform &outVal);
+extern void G_TO_B(Transform3D const &inVal, btTransform &outVal);
 
 extern void UNSCALE_BT_BASIS(btTransform &scaledBasis);
 #endif
diff --git a/modules/bullet/collision_object_bullet.cpp b/modules/bullet/collision_object_bullet.cpp
index d9f5beb5a1..c45bd5bbc0 100644
--- a/modules/bullet/collision_object_bullet.cpp
+++ b/modules/bullet/collision_object_bullet.cpp
@@ -49,7 +49,7 @@
 
 CollisionObjectBullet::ShapeWrapper::~ShapeWrapper() {}
 
-void CollisionObjectBullet::ShapeWrapper::set_transform(const Transform &p_transform) {
+void CollisionObjectBullet::ShapeWrapper::set_transform(const Transform3D &p_transform) {
 	G_TO_B(p_transform.get_basis().get_scale_abs(), scale);
 	G_TO_B(p_transform, transform);
 	UNSCALE_BT_BASIS(transform);
@@ -193,7 +193,7 @@ int CollisionObjectBullet::get_godot_object_flags() const {
 	return bt_collision_object->getUserIndex2();
 }
 
-void CollisionObjectBullet::set_transform(const Transform &p_global_transform) {
+void CollisionObjectBullet::set_transform(const Transform3D &p_global_transform) {
 	set_body_scale(p_global_transform.basis.get_scale_abs());
 
 	btTransform bt_transform;
@@ -203,8 +203,8 @@ void CollisionObjectBullet::set_transform(const Transform &p_global_transform) {
 	set_transform__bullet(bt_transform);
 }
 
-Transform CollisionObjectBullet::get_transform() const {
-	Transform t;
+Transform3D CollisionObjectBullet::get_transform() const {
+	Transform3D t;
 	B_TO_G(get_transform__bullet(), t);
 	t.basis.scale(body_scale);
 	return t;
@@ -230,7 +230,7 @@ RigidCollisionObjectBullet::~RigidCollisionObjectBullet() {
 	}
 }
 
-void RigidCollisionObjectBullet::add_shape(ShapeBullet *p_shape, const Transform &p_transform, bool p_disabled) {
+void RigidCollisionObjectBullet::add_shape(ShapeBullet *p_shape, const Transform3D &p_transform, bool p_disabled) {
 	shapes.push_back(ShapeWrapper(p_shape, p_transform, !p_disabled));
 	p_shape->add_owner(this);
 	reload_shapes();
@@ -296,7 +296,7 @@ void RigidCollisionObjectBullet::remove_all_shapes(bool p_permanentlyFromThisBod
 	}
 }
 
-void RigidCollisionObjectBullet::set_shape_transform(int p_index, const Transform &p_transform) {
+void RigidCollisionObjectBullet::set_shape_transform(int p_index, const Transform3D &p_transform) {
 	ERR_FAIL_INDEX(p_index, get_shape_count());
 
 	shapes.write[p_index].set_transform(p_transform);
@@ -307,8 +307,8 @@ const btTransform &RigidCollisionObjectBullet::get_bt_shape_transform(int p_inde
 	return shapes[p_index].transform;
 }
 
-Transform RigidCollisionObjectBullet::get_shape_transform(int p_index) const {
-	Transform trs;
+Transform3D RigidCollisionObjectBullet::get_shape_transform(int p_index) const {
+	Transform3D trs;
 	B_TO_G(shapes[p_index].transform, trs);
 	return trs;
 }
diff --git a/modules/bullet/collision_object_bullet.h b/modules/bullet/collision_object_bullet.h
index c8081a53f1..944ab89b87 100644
--- a/modules/bullet/collision_object_bullet.h
+++ b/modules/bullet/collision_object_bullet.h
@@ -31,7 +31,7 @@
 #ifndef COLLISION_OBJECT_BULLET_H
 #define COLLISION_OBJECT_BULLET_H
 
-#include "core/math/transform.h"
+#include "core/math/transform_3d.h"
 #include "core/math/vector3.h"
 #include "core/object/class_db.h"
 #include "core/templates/vset.h"
@@ -83,7 +83,7 @@ public:
 			set_transform(p_transform);
 		}
 
-		ShapeWrapper(ShapeBullet *p_shape, const Transform &p_transform, bool p_active) :
+		ShapeWrapper(ShapeBullet *p_shape, const Transform3D &p_transform, bool p_active) :
 				shape(p_shape),
 				active(p_active) {
 			set_transform(p_transform);
@@ -102,7 +102,7 @@ public:
 			active = otherShape.active;
 		}
 
-		void set_transform(const Transform &p_transform);
+		void set_transform(const Transform3D &p_transform);
 		void set_transform(const btTransform &p_transform);
 		btTransform get_adjusted_transform() const;
 
@@ -202,8 +202,8 @@ public:
 	void set_godot_object_flags(int flags);
 	int get_godot_object_flags() const;
 
-	void set_transform(const Transform &p_global_transform);
-	Transform get_transform() const;
+	void set_transform(const Transform3D &p_global_transform);
+	Transform3D get_transform() const;
 	virtual void set_transform__bullet(const btTransform &p_global_transform);
 	virtual const btTransform &get_transform__bullet() const;
 
@@ -225,7 +225,7 @@ public:
 
 	_FORCE_INLINE_ btCollisionShape *get_main_shape() const { return mainShape; }
 
-	void add_shape(ShapeBullet *p_shape, const Transform &p_transform = Transform(), bool p_disabled = false);
+	void add_shape(ShapeBullet *p_shape, const Transform3D &p_transform = Transform3D(), bool p_disabled = false);
 	void set_shape(int p_index, ShapeBullet *p_shape);
 
 	int get_shape_count() const;
@@ -238,10 +238,10 @@ public:
 	void remove_shape_full(int p_index);
 	void remove_all_shapes(bool p_permanentlyFromThisBody = false, bool p_force_not_reload = false);
 
-	void set_shape_transform(int p_index, const Transform &p_transform);
+	void set_shape_transform(int p_index, const Transform3D &p_transform);
 
 	const btTransform &get_bt_shape_transform(int p_index) const;
-	Transform get_shape_transform(int p_index) const;
+	Transform3D get_shape_transform(int p_index) const;
 
 	void set_shape_disabled(int p_index, bool p_disabled);
 	bool is_shape_disabled(int p_index);
diff --git a/modules/bullet/cone_twist_joint_bullet.cpp b/modules/bullet/cone_twist_joint_bullet.cpp
index e785780c5b..34516d8b3b 100644
--- a/modules/bullet/cone_twist_joint_bullet.cpp
+++ b/modules/bullet/cone_twist_joint_bullet.cpp
@@ -40,16 +40,16 @@
 	@author AndreaCatania
 */
 
-ConeTwistJointBullet::ConeTwistJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform &rbAFrame, const Transform &rbBFrame) :
+ConeTwistJointBullet::ConeTwistJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform3D &rbAFrame, const Transform3D &rbBFrame) :
 		JointBullet() {
-	Transform scaled_AFrame(rbAFrame.scaled(rbA->get_body_scale()));
+	Transform3D scaled_AFrame(rbAFrame.scaled(rbA->get_body_scale()));
 	scaled_AFrame.basis.rotref_posscale_decomposition(scaled_AFrame.basis);
 
 	btTransform btFrameA;
 	G_TO_B(scaled_AFrame, btFrameA);
 
 	if (rbB) {
-		Transform scaled_BFrame(rbBFrame.scaled(rbB->get_body_scale()));
+		Transform3D scaled_BFrame(rbBFrame.scaled(rbB->get_body_scale()));
 		scaled_BFrame.basis.rotref_posscale_decomposition(scaled_BFrame.basis);
 
 		btTransform btFrameB;
diff --git a/modules/bullet/cone_twist_joint_bullet.h b/modules/bullet/cone_twist_joint_bullet.h
index 7d6bafd292..7e51f7d644 100644
--- a/modules/bullet/cone_twist_joint_bullet.h
+++ b/modules/bullet/cone_twist_joint_bullet.h
@@ -43,7 +43,7 @@ class ConeTwistJointBullet : public JointBullet {
 	class btConeTwistConstraint *coneConstraint;
 
 public:
-	ConeTwistJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform &rbAFrame, const Transform &rbBFrame);
+	ConeTwistJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform3D &rbAFrame, const Transform3D &rbBFrame);
 
 	virtual PhysicsServer3D::JointType get_type() const { return PhysicsServer3D::JOINT_CONE_TWIST; }
 
diff --git a/modules/bullet/generic_6dof_joint_bullet.cpp b/modules/bullet/generic_6dof_joint_bullet.cpp
index 43ad6c56d5..7e04d57b9d 100644
--- a/modules/bullet/generic_6dof_joint_bullet.cpp
+++ b/modules/bullet/generic_6dof_joint_bullet.cpp
@@ -40,7 +40,7 @@
 	@author AndreaCatania
 */
 
-Generic6DOFJointBullet::Generic6DOFJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform &frameInA, const Transform &frameInB) :
+Generic6DOFJointBullet::Generic6DOFJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform3D &frameInA, const Transform3D &frameInB) :
 		JointBullet() {
 	for (int i = 0; i < 3; i++) {
 		for (int j = 0; j < PhysicsServer3D::G6DOF_JOINT_FLAG_MAX; j++) {
@@ -48,7 +48,7 @@ Generic6DOFJointBullet::Generic6DOFJointBullet(RigidBodyBullet *rbA, RigidBodyBu
 		}
 	}
 
-	Transform scaled_AFrame(frameInA.scaled(rbA->get_body_scale()));
+	Transform3D scaled_AFrame(frameInA.scaled(rbA->get_body_scale()));
 
 	scaled_AFrame.basis.rotref_posscale_decomposition(scaled_AFrame.basis);
 
@@ -56,7 +56,7 @@ Generic6DOFJointBullet::Generic6DOFJointBullet(RigidBodyBullet *rbA, RigidBodyBu
 	G_TO_B(scaled_AFrame, btFrameA);
 
 	if (rbB) {
-		Transform scaled_BFrame(frameInB.scaled(rbB->get_body_scale()));
+		Transform3D scaled_BFrame(frameInB.scaled(rbB->get_body_scale()));
 
 		scaled_BFrame.basis.rotref_posscale_decomposition(scaled_BFrame.basis);
 
@@ -71,30 +71,30 @@ Generic6DOFJointBullet::Generic6DOFJointBullet(RigidBodyBullet *rbA, RigidBodyBu
 	setup(sixDOFConstraint);
 }
 
-Transform Generic6DOFJointBullet::getFrameOffsetA() const {
+Transform3D Generic6DOFJointBullet::getFrameOffsetA() const {
 	btTransform btTrs = sixDOFConstraint->getFrameOffsetA();
-	Transform gTrs;
+	Transform3D gTrs;
 	B_TO_G(btTrs, gTrs);
 	return gTrs;
 }
 
-Transform Generic6DOFJointBullet::getFrameOffsetB() const {
+Transform3D Generic6DOFJointBullet::getFrameOffsetB() const {
 	btTransform btTrs = sixDOFConstraint->getFrameOffsetB();
-	Transform gTrs;
+	Transform3D gTrs;
 	B_TO_G(btTrs, gTrs);
 	return gTrs;
 }
 
-Transform Generic6DOFJointBullet::getFrameOffsetA() {
+Transform3D Generic6DOFJointBullet::getFrameOffsetA() {
 	btTransform btTrs = sixDOFConstraint->getFrameOffsetA();
-	Transform gTrs;
+	Transform3D gTrs;
 	B_TO_G(btTrs, gTrs);
 	return gTrs;
 }
 
-Transform Generic6DOFJointBullet::getFrameOffsetB() {
+Transform3D Generic6DOFJointBullet::getFrameOffsetB() {
 	btTransform btTrs = sixDOFConstraint->getFrameOffsetB();
-	Transform gTrs;
+	Transform3D gTrs;
 	B_TO_G(btTrs, gTrs);
 	return gTrs;
 }
diff --git a/modules/bullet/generic_6dof_joint_bullet.h b/modules/bullet/generic_6dof_joint_bullet.h
index 62b8e85a81..00567e3085 100644
--- a/modules/bullet/generic_6dof_joint_bullet.h
+++ b/modules/bullet/generic_6dof_joint_bullet.h
@@ -48,14 +48,14 @@ class Generic6DOFJointBullet : public JointBullet {
 	bool flags[3][PhysicsServer3D::G6DOF_JOINT_FLAG_MAX];
 
 public:
-	Generic6DOFJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform &frameInA, const Transform &frameInB);
+	Generic6DOFJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform3D &frameInA, const Transform3D &frameInB);
 
 	virtual PhysicsServer3D::JointType get_type() const { return PhysicsServer3D::JOINT_6DOF; }
 
-	Transform getFrameOffsetA() const;
-	Transform getFrameOffsetB() const;
-	Transform getFrameOffsetA();
-	Transform getFrameOffsetB();
+	Transform3D getFrameOffsetA() const;
+	Transform3D getFrameOffsetB() const;
+	Transform3D getFrameOffsetA();
+	Transform3D getFrameOffsetB();
 
 	void set_linear_lower_limit(const Vector3 &linearLower);
 	void set_linear_upper_limit(const Vector3 &linearUpper);
diff --git a/modules/bullet/hinge_joint_bullet.cpp b/modules/bullet/hinge_joint_bullet.cpp
index 4ceb98729f..b5fe50cf5f 100644
--- a/modules/bullet/hinge_joint_bullet.cpp
+++ b/modules/bullet/hinge_joint_bullet.cpp
@@ -40,16 +40,16 @@
 	@author AndreaCatania
 */
 
-HingeJointBullet::HingeJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform &frameA, const Transform &frameB) :
+HingeJointBullet::HingeJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform3D &frameA, const Transform3D &frameB) :
 		JointBullet() {
-	Transform scaled_AFrame(frameA.scaled(rbA->get_body_scale()));
+	Transform3D scaled_AFrame(frameA.scaled(rbA->get_body_scale()));
 	scaled_AFrame.basis.rotref_posscale_decomposition(scaled_AFrame.basis);
 
 	btTransform btFrameA;
 	G_TO_B(scaled_AFrame, btFrameA);
 
 	if (rbB) {
-		Transform scaled_BFrame(frameB.scaled(rbB->get_body_scale()));
+		Transform3D scaled_BFrame(frameB.scaled(rbB->get_body_scale()));
 		scaled_BFrame.basis.rotref_posscale_decomposition(scaled_BFrame.basis);
 
 		btTransform btFrameB;
diff --git a/modules/bullet/hinge_joint_bullet.h b/modules/bullet/hinge_joint_bullet.h
index 06a95be374..dd0f69ba68 100644
--- a/modules/bullet/hinge_joint_bullet.h
+++ b/modules/bullet/hinge_joint_bullet.h
@@ -41,7 +41,7 @@ class HingeJointBullet : public JointBullet {
 	class btHingeConstraint *hingeConstraint;
 
 public:
-	HingeJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform &frameA, const Transform &frameB);
+	HingeJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform3D &frameA, const Transform3D &frameB);
 	HingeJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Vector3 &pivotInA, const Vector3 &pivotInB, const Vector3 &axisInA, const Vector3 &axisInB);
 
 	virtual PhysicsServer3D::JointType get_type() const { return PhysicsServer3D::JOINT_HINGE; }
diff --git a/modules/bullet/rigid_body_bullet.cpp b/modules/bullet/rigid_body_bullet.cpp
index 675da1a597..def978cf14 100644
--- a/modules/bullet/rigid_body_bullet.cpp
+++ b/modules/bullet/rigid_body_bullet.cpp
@@ -106,11 +106,11 @@ Vector3 BulletPhysicsDirectBodyState3D::get_angular_velocity() const {
 	return body->get_angular_velocity();
 }
 
-void BulletPhysicsDirectBodyState3D::set_transform(const Transform &p_transform) {
+void BulletPhysicsDirectBodyState3D::set_transform(const Transform3D &p_transform) {
 	body->set_transform(p_transform);
 }
 
-Transform BulletPhysicsDirectBodyState3D::get_transform() const {
+Transform3D BulletPhysicsDirectBodyState3D::get_transform() const {
 	return body->get_transform();
 }
 
diff --git a/modules/bullet/rigid_body_bullet.h b/modules/bullet/rigid_body_bullet.h
index 843ff4a7af..606df7134b 100644
--- a/modules/bullet/rigid_body_bullet.h
+++ b/modules/bullet/rigid_body_bullet.h
@@ -107,8 +107,8 @@ public:
 	virtual void set_angular_velocity(const Vector3 &p_velocity) override;
 	virtual Vector3 get_angular_velocity() const override;
 
-	virtual void set_transform(const Transform &p_transform) override;
-	virtual Transform get_transform() const override;
+	virtual void set_transform(const Transform3D &p_transform) override;
+	virtual Transform3D get_transform() const override;
 
 	virtual void add_central_force(const Vector3 &p_force) override;
 	virtual void add_force(const Vector3 &p_force, const Vector3 &p_position = Vector3()) override;
diff --git a/modules/bullet/slider_joint_bullet.cpp b/modules/bullet/slider_joint_bullet.cpp
index 45c892851b..1d83118468 100644
--- a/modules/bullet/slider_joint_bullet.cpp
+++ b/modules/bullet/slider_joint_bullet.cpp
@@ -40,16 +40,16 @@
 	@author AndreaCatania
 */
 
-SliderJointBullet::SliderJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform &frameInA, const Transform &frameInB) :
+SliderJointBullet::SliderJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform3D &frameInA, const Transform3D &frameInB) :
 		JointBullet() {
-	Transform scaled_AFrame(frameInA.scaled(rbA->get_body_scale()));
+	Transform3D scaled_AFrame(frameInA.scaled(rbA->get_body_scale()));
 	scaled_AFrame.basis.rotref_posscale_decomposition(scaled_AFrame.basis);
 
 	btTransform btFrameA;
 	G_TO_B(scaled_AFrame, btFrameA);
 
 	if (rbB) {
-		Transform scaled_BFrame(frameInB.scaled(rbB->get_body_scale()));
+		Transform3D scaled_BFrame(frameInB.scaled(rbB->get_body_scale()));
 		scaled_BFrame.basis.rotref_posscale_decomposition(scaled_BFrame.basis);
 
 		btTransform btFrameB;
@@ -70,44 +70,44 @@ const RigidBodyBullet *SliderJointBullet::getRigidBodyB() const {
 	return static_cast<RigidBodyBullet *>(sliderConstraint->getRigidBodyB().getUserPointer());
 }
 
-const Transform SliderJointBullet::getCalculatedTransformA() const {
+const Transform3D SliderJointBullet::getCalculatedTransformA() const {
 	btTransform btTransform = sliderConstraint->getCalculatedTransformA();
-	Transform gTrans;
+	Transform3D gTrans;
 	B_TO_G(btTransform, gTrans);
 	return gTrans;
 }
 
-const Transform SliderJointBullet::getCalculatedTransformB() const {
+const Transform3D SliderJointBullet::getCalculatedTransformB() const {
 	btTransform btTransform = sliderConstraint->getCalculatedTransformB();
-	Transform gTrans;
+	Transform3D gTrans;
 	B_TO_G(btTransform, gTrans);
 	return gTrans;
 }
 
-const Transform SliderJointBullet::getFrameOffsetA() const {
+const Transform3D SliderJointBullet::getFrameOffsetA() const {
 	btTransform btTransform = sliderConstraint->getFrameOffsetA();
-	Transform gTrans;
+	Transform3D gTrans;
 	B_TO_G(btTransform, gTrans);
 	return gTrans;
 }
 
-const Transform SliderJointBullet::getFrameOffsetB() const {
+const Transform3D SliderJointBullet::getFrameOffsetB() const {
 	btTransform btTransform = sliderConstraint->getFrameOffsetB();
-	Transform gTrans;
+	Transform3D gTrans;
 	B_TO_G(btTransform, gTrans);
 	return gTrans;
 }
 
-Transform SliderJointBullet::getFrameOffsetA() {
+Transform3D SliderJointBullet::getFrameOffsetA() {
 	btTransform btTransform = sliderConstraint->getFrameOffsetA();
-	Transform gTrans;
+	Transform3D gTrans;
 	B_TO_G(btTransform, gTrans);
 	return gTrans;
 }
 
-Transform SliderJointBullet::getFrameOffsetB() {
+Transform3D SliderJointBullet::getFrameOffsetB() {
 	btTransform btTransform = sliderConstraint->getFrameOffsetB();
-	Transform gTrans;
+	Transform3D gTrans;
 	B_TO_G(btTransform, gTrans);
 	return gTrans;
 }
diff --git a/modules/bullet/slider_joint_bullet.h b/modules/bullet/slider_joint_bullet.h
index 90964671c2..0c93558449 100644
--- a/modules/bullet/slider_joint_bullet.h
+++ b/modules/bullet/slider_joint_bullet.h
@@ -44,18 +44,18 @@ class SliderJointBullet : public JointBullet {
 
 public:
 	/// Reference frame is A
-	SliderJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform &frameInA, const Transform &frameInB);
+	SliderJointBullet(RigidBodyBullet *rbA, RigidBodyBullet *rbB, const Transform3D &frameInA, const Transform3D &frameInB);
 
 	virtual PhysicsServer3D::JointType get_type() const { return PhysicsServer3D::JOINT_SLIDER; }
 
 	const RigidBodyBullet *getRigidBodyA() const;
 	const RigidBodyBullet *getRigidBodyB() const;
-	const Transform getCalculatedTransformA() const;
-	const Transform getCalculatedTransformB() const;
-	const Transform getFrameOffsetA() const;
-	const Transform getFrameOffsetB() const;
-	Transform getFrameOffsetA();
-	Transform getFrameOffsetB();
+	const Transform3D getCalculatedTransformA() const;
+	const Transform3D getCalculatedTransformB() const;
+	const Transform3D getFrameOffsetA() const;
+	const Transform3D getFrameOffsetB() const;
+	Transform3D getFrameOffsetA();
+	Transform3D getFrameOffsetB();
 	real_t getLowerLinLimit() const;
 	void setLowerLinLimit(real_t lowerLimit);
 	real_t getUpperLinLimit() const;
diff --git a/modules/bullet/soft_body_bullet.cpp b/modules/bullet/soft_body_bullet.cpp
index 2c8727baf2..bbbb0e7851 100644
--- a/modules/bullet/soft_body_bullet.cpp
+++ b/modules/bullet/soft_body_bullet.cpp
@@ -136,7 +136,7 @@ void SoftBodyBullet::destroy_soft_body() {
 	bt_soft_body = nullptr;
 }
 
-void SoftBodyBullet::set_soft_transform(const Transform &p_transform) {
+void SoftBodyBullet::set_soft_transform(const Transform3D &p_transform) {
 	reset_all_node_positions();
 	move_all_nodes(p_transform);
 }
@@ -159,7 +159,7 @@ AABB SoftBodyBullet::get_bounds() const {
 	return aabb;
 }
 
-void SoftBodyBullet::move_all_nodes(const Transform &p_transform) {
+void SoftBodyBullet::move_all_nodes(const Transform3D &p_transform) {
 	if (!bt_soft_body) {
 		return;
 	}
diff --git a/modules/bullet/soft_body_bullet.h b/modules/bullet/soft_body_bullet.h
index 87023b2517..63708b57a7 100644
--- a/modules/bullet/soft_body_bullet.h
+++ b/modules/bullet/soft_body_bullet.h
@@ -104,11 +104,11 @@ public:
 	void destroy_soft_body();
 
 	// Special function. This function has bad performance
-	void set_soft_transform(const Transform &p_transform);
+	void set_soft_transform(const Transform3D &p_transform);
 
 	AABB get_bounds() const;
 
-	void move_all_nodes(const Transform &p_transform);
+	void move_all_nodes(const Transform3D &p_transform);
 	void set_node_position(int node_index, const Vector3 &p_global_position);
 	void set_node_position(int node_index, const btVector3 &p_global_position);
 	void get_node_position(int node_index, Vector3 &r_position) const;
diff --git a/modules/bullet/space_bullet.cpp b/modules/bullet/space_bullet.cpp
index bdaec4a09e..712ecb3e22 100644
--- a/modules/bullet/space_bullet.cpp
+++ b/modules/bullet/space_bullet.cpp
@@ -117,7 +117,7 @@ bool BulletPhysicsDirectSpaceState::intersect_ray(const Vector3 &p_from, const V
 	}
 }
 
-int BulletPhysicsDirectSpaceState::intersect_shape(const RID &p_shape, const Transform &p_xform, real_t p_margin, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
+int BulletPhysicsDirectSpaceState::intersect_shape(const RID &p_shape, const Transform3D &p_xform, real_t p_margin, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
 	if (p_result_max <= 0) {
 		return 0;
 	}
@@ -152,7 +152,7 @@ int BulletPhysicsDirectSpaceState::intersect_shape(const RID &p_shape, const Tra
 	return btQuery.m_count;
 }
 
-bool BulletPhysicsDirectSpaceState::cast_motion(const RID &p_shape, const Transform &p_xform, const Vector3 &p_motion, real_t p_margin, real_t &r_closest_safe, real_t &r_closest_unsafe, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas, ShapeRestInfo *r_info) {
+bool BulletPhysicsDirectSpaceState::cast_motion(const RID &p_shape, const Transform3D &p_xform, const Vector3 &p_motion, real_t p_margin, real_t &r_closest_safe, real_t &r_closest_unsafe, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas, ShapeRestInfo *r_info) {
 	r_closest_safe = 0.0f;
 	r_closest_unsafe = 0.0f;
 	btVector3 bt_motion;
@@ -214,7 +214,7 @@ bool BulletPhysicsDirectSpaceState::cast_motion(const RID &p_shape, const Transf
 }
 
 /// Returns the list of contacts pairs in this order: Local contact, other body contact
-bool BulletPhysicsDirectSpaceState::collide_shape(RID p_shape, const Transform &p_shape_xform, real_t p_margin, Vector3 *r_results, int p_result_max, int &r_result_count, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
+bool BulletPhysicsDirectSpaceState::collide_shape(RID p_shape, const Transform3D &p_shape_xform, real_t p_margin, Vector3 *r_results, int p_result_max, int &r_result_count, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
 	if (p_result_max <= 0) {
 		return false;
 	}
@@ -250,7 +250,7 @@ bool BulletPhysicsDirectSpaceState::collide_shape(RID p_shape, const Transform &
 	return btQuery.m_count;
 }
 
-bool BulletPhysicsDirectSpaceState::rest_info(RID p_shape, const Transform &p_shape_xform, real_t p_margin, ShapeRestInfo *r_info, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
+bool BulletPhysicsDirectSpaceState::rest_info(RID p_shape, const Transform3D &p_shape_xform, real_t p_margin, ShapeRestInfo *r_info, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
 	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->getornull(p_shape);
 	ERR_FAIL_COND_V(!shape, false);
 
@@ -908,7 +908,7 @@ static Ref<StandardMaterial3D> red_mat;
 static Ref<StandardMaterial3D> blue_mat;
 #endif
 
-bool SpaceBullet::test_body_motion(RigidBodyBullet *p_body, const Transform &p_from, const Vector3 &p_motion, bool p_infinite_inertia, PhysicsServer3D::MotionResult *r_result, bool p_exclude_raycast_shapes) {
+bool SpaceBullet::test_body_motion(RigidBodyBullet *p_body, const Transform3D &p_from, const Vector3 &p_motion, bool p_infinite_inertia, PhysicsServer3D::MotionResult *r_result, bool p_exclude_raycast_shapes) {
 #if debug_test_motion
 	/// Yes I know this is not good, but I've used it as fast debugging hack.
 	/// I'm leaving it here just for speedup the other eventual debugs
@@ -1062,7 +1062,7 @@ bool SpaceBullet::test_body_motion(RigidBodyBullet *p_body, const Transform &p_f
 	return has_penetration;
 }
 
-int SpaceBullet::test_ray_separation(RigidBodyBullet *p_body, const Transform &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, PhysicsServer3D::SeparationResult *r_results, int p_result_max, real_t p_margin) {
+int SpaceBullet::test_ray_separation(RigidBodyBullet *p_body, const Transform3D &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, PhysicsServer3D::SeparationResult *r_results, int p_result_max, real_t p_margin) {
 	btTransform body_transform;
 	G_TO_B(p_transform, body_transform);
 	UNSCALE_BT_BASIS(body_transform);
diff --git a/modules/bullet/space_bullet.h b/modules/bullet/space_bullet.h
index 87aa2b9e93..36d0538e6b 100644
--- a/modules/bullet/space_bullet.h
+++ b/modules/bullet/space_bullet.h
@@ -78,11 +78,11 @@ public:
 
 	virtual int intersect_point(const Vector3 &p_point, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = 0xFFFFFFFF, bool p_collide_with_bodies = true, bool p_collide_with_areas = false) override;
 	virtual bool intersect_ray(const Vector3 &p_from, const Vector3 &p_to, RayResult &r_result, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = 0xFFFFFFFF, bool p_collide_with_bodies = true, bool p_collide_with_areas = false, bool p_pick_ray = false) override;
-	virtual int intersect_shape(const RID &p_shape, const Transform &p_xform, real_t p_margin, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = 0xFFFFFFFF, bool p_collide_with_bodies = true, bool p_collide_with_areas = false) override;
-	virtual bool cast_motion(const RID &p_shape, const Transform &p_xform, const Vector3 &p_motion, real_t p_margin, real_t &r_closest_safe, real_t &r_closest_unsafe, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = 0xFFFFFFFF, bool p_collide_with_bodies = true, bool p_collide_with_areas = false, ShapeRestInfo *r_info = nullptr) override;
+	virtual int intersect_shape(const RID &p_shape, const Transform3D &p_xform, real_t p_margin, ShapeResult *r_results, int p_result_max, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = 0xFFFFFFFF, bool p_collide_with_bodies = true, bool p_collide_with_areas = false) override;
+	virtual bool cast_motion(const RID &p_shape, const Transform3D &p_xform, const Vector3 &p_motion, real_t p_margin, real_t &r_closest_safe, real_t &r_closest_unsafe, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = 0xFFFFFFFF, bool p_collide_with_bodies = true, bool p_collide_with_areas = false, ShapeRestInfo *r_info = nullptr) override;
 	/// Returns the list of contacts pairs in this order: Local contact, other body contact
-	virtual bool collide_shape(RID p_shape, const Transform &p_shape_xform, real_t p_margin, Vector3 *r_results, int p_result_max, int &r_result_count, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = 0xFFFFFFFF, bool p_collide_with_bodies = true, bool p_collide_with_areas = false) override;
-	virtual bool rest_info(RID p_shape, const Transform &p_shape_xform, real_t p_margin, ShapeRestInfo *r_info, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = 0xFFFFFFFF, bool p_collide_with_bodies = true, bool p_collide_with_areas = false) override;
+	virtual bool collide_shape(RID p_shape, const Transform3D &p_shape_xform, real_t p_margin, Vector3 *r_results, int p_result_max, int &r_result_count, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = 0xFFFFFFFF, bool p_collide_with_bodies = true, bool p_collide_with_areas = false) override;
+	virtual bool rest_info(RID p_shape, const Transform3D &p_shape_xform, real_t p_margin, ShapeRestInfo *r_info, const Set<RID> &p_exclude = Set<RID>(), uint32_t p_collision_mask = 0xFFFFFFFF, bool p_collide_with_bodies = true, bool p_collide_with_areas = false) override;
 	virtual Vector3 get_closest_point_to_object_volume(RID p_object, const Vector3 p_point) const override;
 };
 
@@ -188,8 +188,8 @@ public:
 	real_t get_linear_damp() const { return linear_damp; }
 	real_t get_angular_damp() const { return angular_damp; }
 
-	bool test_body_motion(RigidBodyBullet *p_body, const Transform &p_from, const Vector3 &p_motion, bool p_infinite_inertia, PhysicsServer3D::MotionResult *r_result, bool p_exclude_raycast_shapes);
-	int test_ray_separation(RigidBodyBullet *p_body, const Transform &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, PhysicsServer3D::SeparationResult *r_results, int p_result_max, real_t p_margin);
+	bool test_body_motion(RigidBodyBullet *p_body, const Transform3D &p_from, const Vector3 &p_motion, bool p_infinite_inertia, PhysicsServer3D::MotionResult *r_result, bool p_exclude_raycast_shapes);
+	int test_ray_separation(RigidBodyBullet *p_body, const Transform3D &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, PhysicsServer3D::SeparationResult *r_results, int p_result_max, real_t p_margin);
 
 private:
 	void create_empty_world(bool p_create_soft_world);
diff --git a/modules/csg/csg.cpp b/modules/csg/csg.cpp
index 7387842259..5a37486568 100644
--- a/modules/csg/csg.cpp
+++ b/modules/csg/csg.cpp
@@ -265,7 +265,7 @@ void CSGBrush::build_from_faces(const Vector<Vector3> &p_vertices, const Vector<
 	_regen_face_aabbs();
 }
 
-void CSGBrush::copy_from(const CSGBrush &p_brush, const Transform &p_xform) {
+void CSGBrush::copy_from(const CSGBrush &p_brush, const Transform3D &p_xform) {
 	faces = p_brush.faces;
 	materials = p_brush.materials;
 
diff --git a/modules/csg/csg.h b/modules/csg/csg.h
index 3fbed66e5c..4bd79e15a9 100644
--- a/modules/csg/csg.h
+++ b/modules/csg/csg.h
@@ -33,7 +33,7 @@
 
 #include "core/math/aabb.h"
 #include "core/math/plane.h"
-#include "core/math/transform.h"
+#include "core/math/transform_3d.h"
 #include "core/math/vector2.h"
 #include "core/math/vector3.h"
 #include "core/object/reference.h"
@@ -60,7 +60,7 @@ struct CSGBrush {
 
 	// Create a brush from faces.
 	void build_from_faces(const Vector<Vector3> &p_vertices, const Vector<Vector2> &p_uvs, const Vector<bool> &p_smooth, const Vector<Ref<Material>> &p_materials, const Vector<bool> &p_invert_faces);
-	void copy_from(const CSGBrush &p_brush, const Transform &p_xform);
+	void copy_from(const CSGBrush &p_brush, const Transform3D &p_xform);
 };
 
 struct CSGBrushOperation {
@@ -165,8 +165,8 @@ struct CSGBrushOperation {
 		Vector<Vertex2D> vertices;
 		Vector<Face2D> faces;
 		Plane plane;
-		Transform to_2D;
-		Transform to_3D;
+		Transform3D to_2D;
+		Transform3D to_3D;
 		float vertex_snap2 = 0.0;
 
 		inline int _get_point_idx(const Vector2 &p_point);
diff --git a/modules/csg/csg_gizmos.cpp b/modules/csg/csg_gizmos.cpp
index 8a46dcca65..37a7d96de5 100644
--- a/modules/csg/csg_gizmos.cpp
+++ b/modules/csg/csg_gizmos.cpp
@@ -99,9 +99,9 @@ Variant CSGShape3DGizmoPlugin::get_handle_value(EditorNode3DGizmo *p_gizmo, int
 void CSGShape3DGizmoPlugin::set_handle(EditorNode3DGizmo *p_gizmo, int p_idx, Camera3D *p_camera, const Point2 &p_point) {
 	CSGShape3D *cs = Object::cast_to<CSGShape3D>(p_gizmo->get_spatial_node());
 
-	Transform gt = cs->get_global_transform();
+	Transform3D gt = cs->get_global_transform();
 	//gt.orthonormalize();
-	Transform gi = gt.affine_inverse();
+	Transform3D gi = gt.affine_inverse();
 
 	Vector3 ray_from = p_camera->project_ray_origin(p_point);
 	Vector3 ray_dir = p_camera->project_ray_normal(p_point);
diff --git a/modules/csg/csg_shape.cpp b/modules/csg/csg_shape.cpp
index 67dfdfb5eb..d6690bb96c 100644
--- a/modules/csg/csg_shape.cpp
+++ b/modules/csg/csg_shape.cpp
@@ -578,7 +578,7 @@ Array CSGShape3D::get_meshes() const {
 	if (root_mesh.is_valid()) {
 		Array arr;
 		arr.resize(2);
-		arr[0] = Transform();
+		arr[0] = Transform3D();
 		arr[1] = root_mesh;
 		return arr;
 	}
@@ -1978,13 +1978,13 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 				float u1 = 0.0;
 				float u2 = path_continuous_u ? 0.0 : 1.0;
 
-				Transform path_to_this;
+				Transform3D path_to_this;
 				if (!path_local) {
 					// center on paths origin
 					path_to_this = get_global_transform().affine_inverse() * path->get_global_transform();
 				}
 
-				Transform prev_xf;
+				Transform3D prev_xf;
 
 				Vector3 lookat_dir;
 
@@ -2006,7 +2006,7 @@ CSGBrush *CSGPolygon3D::_build_brush() {
 						ofs = 0.0;
 					}
 
-					Transform xf;
+					Transform3D xf;
 					xf.origin = curve->interpolate_baked(ofs);
 
 					Vector3 local_dir;
diff --git a/modules/csg/doc_classes/CSGShape3D.xml b/modules/csg/doc_classes/CSGShape3D.xml
index dac556c7f1..01ec46e707 100644
--- a/modules/csg/doc_classes/CSGShape3D.xml
+++ b/modules/csg/doc_classes/CSGShape3D.xml
@@ -31,7 +31,7 @@
 			<return type="Array">
 			</return>
 			<description>
-				Returns an [Array] with two elements, the first is the [Transform] of this node and the second is the root [Mesh] of this node. Only works when this node is the root shape.
+				Returns an [Array] with two elements, the first is the [Transform3D] of this node and the second is the root [Mesh] of this node. Only works when this node is the root shape.
 			</description>
 		</method>
 		<method name="is_root_shape" qualifiers="const">
diff --git a/modules/fbx/README.md b/modules/fbx/README.md
index 69a50d4bea..8eca4bd3c9 100644
--- a/modules/fbx/README.md
+++ b/modules/fbx/README.md
@@ -79,23 +79,23 @@ enum RotOrder {
 // references: ComputePivotTransform / run the calculation
 // This is the local pivot transform for the node, not the global transforms
 Transform ComputePivotTransform(
-		Transform chain[TransformationComp_MAXIMUM],
-		Transform &geometric_transform) {
+		Transform3D chain[TransformationComp_MAXIMUM],
+		Transform3D &geometric_transform) {
 	// Maya pivots
-	Transform T = chain[TransformationComp_Translation];
-	Transform Roff = chain[TransformationComp_RotationOffset];
-	Transform Rp = chain[TransformationComp_RotationPivot];
-	Transform Rpre = chain[TransformationComp_PreRotation];
-	Transform R = chain[TransformationComp_Rotation];
-	Transform Rpost = chain[TransformationComp_PostRotation];
-	Transform Soff = chain[TransformationComp_ScalingOffset];
-	Transform Sp = chain[TransformationComp_ScalingPivot];
-	Transform S = chain[TransformationComp_Scaling];
+	Transform3D T = chain[TransformationComp_Translation];
+	Transform3D Roff = chain[TransformationComp_RotationOffset];
+	Transform3D Rp = chain[TransformationComp_RotationPivot];
+	Transform3D Rpre = chain[TransformationComp_PreRotation];
+	Transform3D R = chain[TransformationComp_Rotation];
+	Transform3D Rpost = chain[TransformationComp_PostRotation];
+	Transform3D Soff = chain[TransformationComp_ScalingOffset];
+	Transform3D Sp = chain[TransformationComp_ScalingPivot];
+	Transform3D S = chain[TransformationComp_Scaling];
 
 	// 3DS Max Pivots
-	Transform OT = chain[TransformationComp_GeometricTranslation];
-	Transform OR = chain[TransformationComp_GeometricRotation];
-	Transform OS = chain[TransformationComp_GeometricScaling];
+	Transform3D OT = chain[TransformationComp_GeometricTranslation];
+	Transform3D OR = chain[TransformationComp_GeometricRotation];
+	Transform3D OS = chain[TransformationComp_GeometricScaling];
 
 	// Calculate 3DS max pivot transform - use geometric space (e.g doesn't effect children nodes only the current node)
 	geometric_transform = OT * OR * OS;
diff --git a/modules/fbx/data/pivot_transform.cpp b/modules/fbx/data/pivot_transform.cpp
index f4055c830f..3e4e197fbf 100644
--- a/modules/fbx/data/pivot_transform.cpp
+++ b/modules/fbx/data/pivot_transform.cpp
@@ -116,8 +116,8 @@ void PivotTransform::ReadTransformChain() {
 	}
 }
 
-Transform PivotTransform::ComputeLocalTransform(Vector3 p_translation, Quat p_rotation, Vector3 p_scaling) const {
-	Transform T, Roff, Rp, Soff, Sp, S;
+Transform3D PivotTransform::ComputeLocalTransform(Vector3 p_translation, Quat p_rotation, Vector3 p_scaling) const {
+	Transform3D T, Roff, Rp, Soff, Sp, S;
 
 	// Here I assume this is the operation which needs done.
 	// Its WorldTransform * V
@@ -132,29 +132,29 @@ Transform PivotTransform::ComputeLocalTransform(Vector3 p_translation, Quat p_ro
 	// Scaling node
 	S.scale(p_scaling);
 	// Rotation pivots
-	Transform Rpre = Transform(pre_rotation);
-	Transform R = Transform(p_rotation);
-	Transform Rpost = Transform(post_rotation);
+	Transform3D Rpre = Transform3D(pre_rotation);
+	Transform3D R = Transform3D(p_rotation);
+	Transform3D Rpost = Transform3D(post_rotation);
 
 	return T * Roff * Rp * Rpre * R * Rpost.affine_inverse() * Rp.affine_inverse() * Soff * Sp * S * Sp.affine_inverse();
 }
 
-Transform PivotTransform::ComputeGlobalTransform(Transform t) const {
+Transform3D PivotTransform::ComputeGlobalTransform(Transform3D t) const {
 	Vector3 pos = t.origin;
 	Vector3 scale = t.basis.get_scale();
 	Quat rot = t.basis.get_rotation_quat();
 	return ComputeGlobalTransform(pos, rot, scale);
 }
 
-Transform PivotTransform::ComputeLocalTransform(Transform t) const {
+Transform3D PivotTransform::ComputeLocalTransform(Transform3D t) const {
 	Vector3 pos = t.origin;
 	Vector3 scale = t.basis.get_scale();
 	Quat rot = t.basis.get_rotation_quat();
 	return ComputeLocalTransform(pos, rot, scale);
 }
 
-Transform PivotTransform::ComputeGlobalTransform(Vector3 p_translation, Quat p_rotation, Vector3 p_scaling) const {
-	Transform T, Roff, Rp, Soff, Sp, S;
+Transform3D PivotTransform::ComputeGlobalTransform(Vector3 p_translation, Quat p_rotation, Vector3 p_scaling) const {
+	Transform3D T, Roff, Rp, Soff, Sp, S;
 
 	// Here I assume this is the operation which needs done.
 	// Its WorldTransform * V
@@ -170,26 +170,26 @@ Transform PivotTransform::ComputeGlobalTransform(Vector3 p_translation, Quat p_r
 	S.scale(p_scaling);
 
 	// Rotation pivots
-	Transform Rpre = Transform(pre_rotation);
-	Transform R = Transform(p_rotation);
-	Transform Rpost = Transform(post_rotation);
+	Transform3D Rpre = Transform3D(pre_rotation);
+	Transform3D R = Transform3D(p_rotation);
+	Transform3D Rpost = Transform3D(post_rotation);
 
-	Transform parent_global_xform;
-	Transform parent_local_scaling_m;
+	Transform3D parent_global_xform;
+	Transform3D parent_local_scaling_m;
 
 	if (parent_transform.is_valid()) {
 		parent_global_xform = parent_transform->GlobalTransform;
 		parent_local_scaling_m = parent_transform->Local_Scaling_Matrix;
 	}
 
-	Transform local_rotation_m, parent_global_rotation_m;
+	Transform3D local_rotation_m, parent_global_rotation_m;
 	Quat parent_global_rotation = parent_global_xform.basis.get_rotation_quat();
 	parent_global_rotation_m.basis.set_quat(parent_global_rotation);
 	local_rotation_m = Rpre * R * Rpost;
 
 	//Basis parent_global_rotation = Basis(parent_global_xform.get_basis().get_rotation_quat().normalized());
 
-	Transform local_shear_scaling, parent_shear_scaling, parent_shear_rotation, parent_shear_translation;
+	Transform3D local_shear_scaling, parent_shear_scaling, parent_shear_rotation, parent_shear_translation;
 	Vector3 parent_translation = parent_global_xform.get_origin();
 	parent_shear_translation.origin = parent_translation;
 	parent_shear_rotation = parent_shear_translation.affine_inverse() * parent_global_xform;
@@ -197,26 +197,26 @@ Transform PivotTransform::ComputeGlobalTransform(Vector3 p_translation, Quat p_r
 	local_shear_scaling = S;
 
 	// Inherit type handler - we don't care about T here, just reordering RSrs etc.
-	Transform global_rotation_scale;
+	Transform3D global_rotation_scale;
 	if (inherit_type == FBXDocParser::Transform_RrSs) {
 		global_rotation_scale = parent_global_rotation_m * local_rotation_m * parent_shear_scaling * local_shear_scaling;
 	} else if (inherit_type == FBXDocParser::Transform_RSrs) {
 		global_rotation_scale = parent_global_rotation_m * parent_shear_scaling * local_rotation_m * local_shear_scaling;
 	} else if (inherit_type == FBXDocParser::Transform_Rrs) {
-		Transform parent_global_shear_m_noLocal = parent_shear_scaling * parent_local_scaling_m.affine_inverse();
+		Transform3D parent_global_shear_m_noLocal = parent_shear_scaling * parent_local_scaling_m.affine_inverse();
 		global_rotation_scale = parent_global_rotation_m * local_rotation_m * parent_global_shear_m_noLocal * local_shear_scaling;
 	}
-	Transform local_transform = T * Roff * Rp * Rpre * R * Rpost.affine_inverse() * Rp.affine_inverse() * Soff * Sp * S * Sp.affine_inverse();
-	//Transform local_translation_pivoted = Transform(Basis(), LocalTransform.origin);
+	Transform3D local_transform = T * Roff * Rp * Rpre * R * Rpost.affine_inverse() * Rp.affine_inverse() * Soff * Sp * S * Sp.affine_inverse();
+	//Transform3D local_translation_pivoted = Transform3D(Basis(), LocalTransform.origin);
 
-	ERR_FAIL_COND_V_MSG(local_transform.basis.determinant() == 0, Transform(), "Det == 0 prevented in scene file");
+	ERR_FAIL_COND_V_MSG(local_transform.basis.determinant() == 0, Transform3D(), "Det == 0 prevented in scene file");
 
 	// manual hack to force SSC not to be compensated for - until we can handle it properly with tests
 	return parent_global_xform * local_transform;
 }
 
 void PivotTransform::ComputePivotTransform() {
-	Transform T, Roff, Rp, Soff, Sp, S;
+	Transform3D T, Roff, Rp, Soff, Sp, S;
 
 	// Here I assume this is the operation which needs done.
 	// Its WorldTransform * V
@@ -237,26 +237,26 @@ void PivotTransform::ComputePivotTransform() {
 	Local_Scaling_Matrix = S; // copy for when node / child is looking for the value of this.
 
 	// Rotation pivots
-	Transform Rpre = Transform(pre_rotation);
-	Transform R = Transform(rotation);
-	Transform Rpost = Transform(post_rotation);
+	Transform3D Rpre = Transform3D(pre_rotation);
+	Transform3D R = Transform3D(rotation);
+	Transform3D Rpost = Transform3D(post_rotation);
 
-	Transform parent_global_xform;
-	Transform parent_local_scaling_m;
+	Transform3D parent_global_xform;
+	Transform3D parent_local_scaling_m;
 
 	if (parent_transform.is_valid()) {
 		parent_global_xform = parent_transform->GlobalTransform;
 		parent_local_scaling_m = parent_transform->Local_Scaling_Matrix;
 	}
 
-	Transform local_rotation_m, parent_global_rotation_m;
+	Transform3D local_rotation_m, parent_global_rotation_m;
 	Quat parent_global_rotation = parent_global_xform.basis.get_rotation_quat();
 	parent_global_rotation_m.basis.set_quat(parent_global_rotation);
 	local_rotation_m = Rpre * R * Rpost;
 
 	//Basis parent_global_rotation = Basis(parent_global_xform.get_basis().get_rotation_quat().normalized());
 
-	Transform local_shear_scaling, parent_shear_scaling, parent_shear_rotation, parent_shear_translation;
+	Transform3D local_shear_scaling, parent_shear_scaling, parent_shear_rotation, parent_shear_translation;
 	Vector3 parent_translation = parent_global_xform.get_origin();
 	parent_shear_translation.origin = parent_translation;
 	parent_shear_rotation = parent_shear_translation.affine_inverse() * parent_global_xform;
@@ -264,24 +264,24 @@ void PivotTransform::ComputePivotTransform() {
 	local_shear_scaling = S;
 
 	// Inherit type handler - we don't care about T here, just reordering RSrs etc.
-	Transform global_rotation_scale;
+	Transform3D global_rotation_scale;
 	if (inherit_type == FBXDocParser::Transform_RrSs) {
 		global_rotation_scale = parent_global_rotation_m * local_rotation_m * parent_shear_scaling * local_shear_scaling;
 	} else if (inherit_type == FBXDocParser::Transform_RSrs) {
 		global_rotation_scale = parent_global_rotation_m * parent_shear_scaling * local_rotation_m * local_shear_scaling;
 	} else if (inherit_type == FBXDocParser::Transform_Rrs) {
-		Transform parent_global_shear_m_noLocal = parent_shear_scaling * parent_local_scaling_m.inverse();
+		Transform3D parent_global_shear_m_noLocal = parent_shear_scaling * parent_local_scaling_m.inverse();
 		global_rotation_scale = parent_global_rotation_m * local_rotation_m * parent_global_shear_m_noLocal * local_shear_scaling;
 	}
-	LocalTransform = Transform();
+	LocalTransform = Transform3D();
 	LocalTransform = T * Roff * Rp * Rpre * R * Rpost.affine_inverse() * Rp.affine_inverse() * Soff * Sp * S * Sp.affine_inverse();
 
 	ERR_FAIL_COND_MSG(LocalTransform.basis.determinant() == 0, "invalid scale reset");
 
-	Transform local_translation_pivoted = Transform(Basis(), LocalTransform.origin);
-	GlobalTransform = Transform();
+	Transform3D local_translation_pivoted = Transform3D(Basis(), LocalTransform.origin);
+	GlobalTransform = Transform3D();
 	//GlobalTransform = parent_global_xform * LocalTransform;
-	Transform global_origin = Transform(Basis(), parent_translation);
+	Transform3D global_origin = Transform3D(Basis(), parent_translation);
 	GlobalTransform = (global_origin * local_translation_pivoted) * global_rotation_scale;
 
 	ImportUtils::debug_xform("local xform calculation", LocalTransform);
diff --git a/modules/fbx/data/pivot_transform.h b/modules/fbx/data/pivot_transform.h
index 9996027870..8ed8358b70 100644
--- a/modules/fbx/data/pivot_transform.h
+++ b/modules/fbx/data/pivot_transform.h
@@ -31,7 +31,7 @@
 #ifndef PIVOT_TRANSFORM_H
 #define PIVOT_TRANSFORM_H
 
-#include "core/math/transform.h"
+#include "core/math/transform_3d.h"
 #include "core/object/reference.h"
 
 #include "model_abstraction.h"
@@ -85,10 +85,10 @@ struct PivotTransform : Reference, ModelAbstraction {
 		print_verbose("raw post_rotation " + raw_post_rotation * (180 / Math_PI));
 	}
 
-	Transform ComputeGlobalTransform(Transform t) const;
-	Transform ComputeLocalTransform(Transform t) const;
-	Transform ComputeGlobalTransform(Vector3 p_translation, Quat p_rotation, Vector3 p_scaling) const;
-	Transform ComputeLocalTransform(Vector3 p_translation, Quat p_rotation, Vector3 p_scaling) const;
+	Transform3D ComputeGlobalTransform(Transform3D t) const;
+	Transform3D ComputeLocalTransform(Transform3D t) const;
+	Transform3D ComputeGlobalTransform(Vector3 p_translation, Quat p_rotation, Vector3 p_scaling) const;
+	Transform3D ComputeLocalTransform(Vector3 p_translation, Quat p_rotation, Vector3 p_scaling) const;
 
 	/* Extract into xforms and calculate once */
 	void ComputePivotTransform();
@@ -105,10 +105,10 @@ struct PivotTransform : Reference, ModelAbstraction {
 	//Transform chain[TransformationComp_MAXIMUM];
 
 	// cached for later use
-	Transform GlobalTransform = Transform();
-	Transform LocalTransform = Transform();
-	Transform Local_Scaling_Matrix = Transform(); // used for inherit type.
-	Transform GeometricTransform = Transform(); // 3DS max only
+	Transform3D GlobalTransform = Transform3D();
+	Transform3D LocalTransform = Transform3D();
+	Transform3D Local_Scaling_Matrix = Transform3D(); // used for inherit type.
+	Transform3D GeometricTransform = Transform3D(); // 3DS max only
 	FBXDocParser::TransformInheritance inherit_type = FBXDocParser::TransformInheritance_MAX; // maya fbx requires this - sorry <3
 };
 
diff --git a/modules/fbx/editor_scene_importer_fbx.cpp b/modules/fbx/editor_scene_importer_fbx.cpp
index f60277f60a..b9eaedb8a6 100644
--- a/modules/fbx/editor_scene_importer_fbx.cpp
+++ b/modules/fbx/editor_scene_importer_fbx.cpp
@@ -1023,7 +1023,7 @@ Node3D *EditorSceneImporterFBX::_generate_scene(
 							bone = state.fbx_bone_map[target_id];
 						}
 
-						Transform target_transform;
+						Transform3D target_transform;
 
 						if (state.fbx_target_map.has(target_id)) {
 							Ref<FBXNode> node_ref = state.fbx_target_map[target_id];
@@ -1165,7 +1165,7 @@ Node3D *EditorSceneImporterFBX::_generate_scene(
 						}
 
 						bool valid_rest = false;
-						Transform bone_rest;
+						Transform3D bone_rest;
 						int skeleton_bone = -1;
 						if (state.fbx_bone_map.has(target_id)) {
 							if (bone.is_valid() && bone->fbx_skeleton.is_valid()) {
@@ -1208,10 +1208,10 @@ Node3D *EditorSceneImporterFBX::_generate_scene(
 
 							// node animations must also include pivots
 							if (skeleton_bone >= 0) {
-								Transform xform = Transform();
+								Transform3D xform = Transform3D();
 								xform.basis.set_quat_scale(rot, scale);
 								xform.origin = pos;
-								const Transform t = bone_rest.affine_inverse() * xform;
+								const Transform3D t = bone_rest.affine_inverse() * xform;
 
 								// populate	this again
 								rot = t.basis.get_rotation_quat();
diff --git a/modules/fbx/fbx_parser/FBXDeformer.cpp b/modules/fbx/fbx_parser/FBXDeformer.cpp
index 039718ae15..4220ba62a7 100644
--- a/modules/fbx/fbx_parser/FBXDeformer.cpp
+++ b/modules/fbx/fbx_parser/FBXDeformer.cpp
@@ -78,7 +78,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXMeshGeometry.h"
 #include "FBXParser.h"
 #include "core/math/math_funcs.h"
-#include "core/math/transform.h"
+#include "core/math/transform_3d.h"
 
 #include <iostream>
 
diff --git a/modules/fbx/fbx_parser/FBXDocument.h b/modules/fbx/fbx_parser/FBXDocument.h
index e01e0471aa..885ff8fca4 100644
--- a/modules/fbx/fbx_parser/FBXDocument.h
+++ b/modules/fbx/fbx_parser/FBXDocument.h
@@ -37,7 +37,7 @@
 #include "FBXCommon.h"
 #include "FBXParser.h"
 #include "FBXProperties.h"
-#include "core/math/transform.h"
+#include "core/math/transform_3d.h"
 #include "core/math/vector2.h"
 #include "core/math/vector3.h"
 #include "core/string/print_string.h"
@@ -242,13 +242,13 @@ public:
 		return target_id;
 	}
 
-	Transform GetBindPose() const {
+	Transform3D GetBindPose() const {
 		return transform;
 	}
 
 private:
 	uint64_t target_id = 0;
-	Transform transform;
+	Transform3D transform;
 };
 
 /** DOM base class for FBX cameras attached to a node */
@@ -905,11 +905,11 @@ public:
 	}
 
 	/** */
-	const Transform &GetTransform() const {
+	const Transform3D &GetTransform() const {
 		return transform;
 	}
 
-	const Transform &TransformLink() const {
+	const Transform3D &TransformLink() const {
 		return transformLink;
 	}
 
@@ -917,7 +917,7 @@ public:
 		return node;
 	}
 
-	const Transform &TransformAssociateModel() const {
+	const Transform3D &TransformAssociateModel() const {
 		return transformAssociateModel;
 	}
 
@@ -941,9 +941,9 @@ private:
 	std::vector<float> weights;
 	std::vector<unsigned int> indices;
 
-	Transform transform;
-	Transform transformLink;
-	Transform transformAssociateModel;
+	Transform3D transform;
+	Transform3D transformLink;
+	Transform3D transformAssociateModel;
 	SkinLinkMode link_mode;
 	bool valid_transformAssociateModel = false;
 	const Model *node = nullptr;
diff --git a/modules/fbx/fbx_parser/FBXParser.cpp b/modules/fbx/fbx_parser/FBXParser.cpp
index 98435b5c0f..163518d18f 100644
--- a/modules/fbx/fbx_parser/FBXParser.cpp
+++ b/modules/fbx/fbx_parser/FBXParser.cpp
@@ -82,7 +82,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXParser.h"
 #include "FBXTokenizer.h"
 #include "core/math/math_defs.h"
-#include "core/math/transform.h"
+#include "core/math/transform_3d.h"
 #include "core/math/vector3.h"
 #include "core/string/print_string.h"
 
@@ -1157,7 +1157,7 @@ void ParseVectorDataArray(std::vector<int64_t> &out, const ElementPtr el) {
 }
 
 // ------------------------------------------------------------------------------------------------
-Transform ReadMatrix(const ElementPtr element) {
+Transform3D ReadMatrix(const ElementPtr element) {
 	std::vector<float> values;
 	ParseVectorDataArray(values, element);
 
@@ -1172,7 +1172,7 @@ Transform ReadMatrix(const ElementPtr element) {
 		}
 	}
 
-	Transform xform;
+	Transform3D xform;
 	Basis basis;
 
 	basis.set(
diff --git a/modules/fbx/fbx_parser/FBXParser.h b/modules/fbx/fbx_parser/FBXParser.h
index 8b248e8791..93836c2205 100644
--- a/modules/fbx/fbx_parser/FBXParser.h
+++ b/modules/fbx/fbx_parser/FBXParser.h
@@ -81,7 +81,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <memory>
 
 #include "core/math/color.h"
-#include "core/math/transform.h"
+#include "core/math/transform_3d.h"
 #include "core/math/vector2.h"
 #include "core/math/vector3.h"
 
@@ -264,7 +264,7 @@ TokenPtr GetRequiredToken(const ElementPtr el, unsigned int index);
 
 // ------------------------------------------------------------------------------------------------
 // read a 4x4 matrix from an array of 16 floats
-Transform ReadMatrix(const ElementPtr element);
+Transform3D ReadMatrix(const ElementPtr element);
 } // namespace FBXDocParser
 
 #endif // FBX_PARSER_H
diff --git a/modules/fbx/tools/import_utils.cpp b/modules/fbx/tools/import_utils.cpp
index 368aa09a75..259000d2a4 100644
--- a/modules/fbx/tools/import_utils.cpp
+++ b/modules/fbx/tools/import_utils.cpp
@@ -121,9 +121,9 @@ Vector3 ImportUtils::QuaternionToEuler(FBXDocParser::Model::RotOrder mode, const
 	return BasisToEuler(mode, p_rotation);
 }
 
-Transform get_unscaled_transform(const Transform &p_initial, real_t p_scale) {
-	Transform unscaled = Transform(p_initial.basis, p_initial.origin * p_scale);
-	ERR_FAIL_COND_V_MSG(unscaled.basis.determinant() == 0, Transform(), "det is zero unscaled?");
+Transform3D get_unscaled_transform(const Transform3D &p_initial, real_t p_scale) {
+	Transform3D unscaled = Transform3D(p_initial.basis, p_initial.origin * p_scale);
+	ERR_FAIL_COND_V_MSG(unscaled.basis.determinant() == 0, Transform3D(), "det is zero unscaled?");
 	return unscaled;
 }
 
diff --git a/modules/fbx/tools/import_utils.h b/modules/fbx/tools/import_utils.h
index cf0f811e35..3972f7520e 100644
--- a/modules/fbx/tools/import_utils.h
+++ b/modules/fbx/tools/import_utils.h
@@ -64,7 +64,7 @@ public:
 	/// Converts quaternion into rotation order vector (in rad).
 	static Vector3 QuaternionToEuler(FBXDocParser::Model::RotOrder mode, const Quat &p_rotation);
 
-	static void debug_xform(String name, const Transform &t) {
+	static void debug_xform(String name, const Transform3D &t) {
 		print_verbose(name + " " + t.origin + " rotation: " + (t.basis.get_euler() * (180 / Math_PI)));
 	}
 
@@ -391,7 +391,7 @@ public:
 };
 
 // Apply the transforms so the basis will have scale 1.
-Transform get_unscaled_transform(const Transform &p_initial, real_t p_scale);
+Transform3D get_unscaled_transform(const Transform3D &p_initial, real_t p_scale);
 
 /// Uses the Newell's method to compute any polygon normal.
 /// The polygon must be at least size of 3 or bigger.
diff --git a/modules/gdnative/gdnative/transform.cpp b/modules/gdnative/gdnative/transform_3d.cpp
index bfaaa13db2..8bd2a68d63 100644
--- a/modules/gdnative/gdnative/transform.cpp
+++ b/modules/gdnative/gdnative/transform_3d.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  transform.cpp                                                        */
+/*  transform_3d.cpp                                                     */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,22 +28,22 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "gdnative/transform.h"
+#include "gdnative/transform_3d.h"
 
-#include "core/math/transform.h"
+#include "core/math/transform_3d.h"
 
-static_assert(sizeof(godot_transform) == sizeof(Transform), "Transform size mismatch");
+static_assert(sizeof(godot_transform3d) == sizeof(Transform3D), "Transform3D size mismatch");
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-void GDAPI godot_transform_new(godot_transform *p_self) {
-	memnew_placement(p_self, Transform);
+void GDAPI godot_transform3d_new(godot_transform3d *p_self) {
+	memnew_placement(p_self, Transform3D);
 }
 
-void GDAPI godot_transform_new_copy(godot_transform *r_dest, const godot_transform *p_src) {
-	memnew_placement(r_dest, Transform(*(Transform *)p_src));
+void GDAPI godot_transform3d_new_copy(godot_transform3d *r_dest, const godot_transform3d *p_src) {
+	memnew_placement(r_dest, Transform3D(*(Transform3D *)p_src));
 }
 
 #ifdef __cplusplus
diff --git a/modules/gdnative/gdnative/variant.cpp b/modules/gdnative/gdnative/variant.cpp
index 7801e21ab2..c588704627 100644
--- a/modules/gdnative/gdnative/variant.cpp
+++ b/modules/gdnative/gdnative/variant.cpp
@@ -161,9 +161,9 @@ void GDAPI godot_variant_new_basis(godot_variant *r_dest, const godot_basis *p_b
 	memnew_placement_custom(dest, Variant, Variant(*basis));
 }
 
-void GDAPI godot_variant_new_transform(godot_variant *r_dest, const godot_transform *p_trans) {
+void GDAPI godot_variant_new_transform3d(godot_variant *r_dest, const godot_transform3d *p_trans) {
 	Variant *dest = (Variant *)r_dest;
-	const Transform *trans = (const Transform *)p_trans;
+	const Transform3D *trans = (const Transform3D *)p_trans;
 	memnew_placement_custom(dest, Variant, Variant(*trans));
 }
 
@@ -402,10 +402,10 @@ godot_basis GDAPI godot_variant_as_basis(const godot_variant *p_self) {
 	return raw_dest;
 }
 
-godot_transform GDAPI godot_variant_as_transform(const godot_variant *p_self) {
-	godot_transform raw_dest;
+godot_transform3d GDAPI godot_variant_as_transform3d(const godot_variant *p_self) {
+	godot_transform3d raw_dest;
 	const Variant *self = (const Variant *)p_self;
-	Transform *dest = (Transform *)&raw_dest;
+	Transform3D *dest = (Transform3D *)&raw_dest;
 	*dest = *self;
 	return raw_dest;
 }
diff --git a/modules/gdnative/gdnative_api.json b/modules/gdnative/gdnative_api.json
index 489083e795..ec825229ac 100644
--- a/modules/gdnative/gdnative_api.json
+++ b/modules/gdnative/gdnative_api.json
@@ -511,7 +511,7 @@
 				]
 			},
 			{
-				"name": "godot_variant_new_transform",
+				"name": "godot_variant_new_transform3d",
 				"return_type": "void",
 				"arguments": [
 					[
@@ -519,7 +519,7 @@
 						"r_dest"
 					],
 					[
-						"const godot_transform *",
+						"const godot_transform3d *",
 						"p_trans"
 					]
 				]
@@ -923,8 +923,8 @@
 				]
 			},
 			{
-				"name": "godot_variant_as_transform",
-				"return_type": "godot_transform",
+				"name": "godot_variant_as_transform3d",
+				"return_type": "godot_transform3d",
 				"arguments": [
 					[
 						"const godot_variant *",
@@ -4344,25 +4344,25 @@
 				]
 			},
 			{
-				"name": "godot_transform_new",
+				"name": "godot_transform3d_new",
 				"return_type": "void",
 				"arguments": [
 					[
-						"godot_transform *",
+						"godot_transform3d *",
 						"r_dest"
 					]
 				]
 			},
 			{
-				"name": "godot_transform_new_copy",
+				"name": "godot_transform3d_new_copy",
 				"return_type": "void",
 				"arguments": [
 					[
-						"godot_transform *",
+						"godot_transform3d *",
 						"r_dest"
 					],
 					[
-						"const godot_transform *",
+						"const godot_transform3d *",
 						"p_src"
 					]
 				]
@@ -5073,7 +5073,7 @@
 				},
 				{
 					"name": "godot_xr_get_reference_frame",
-					"return_type": "godot_transform",
+					"return_type": "godot_transform3d",
 					"arguments": []
 				},
 				{
@@ -5145,7 +5145,7 @@
 							"p_controller_id"
 						],
 						[
-							"godot_transform *",
+							"godot_transform3d *",
 							"p_transform"
 						],
 						[
diff --git a/modules/gdnative/include/gdnative/gdnative.h b/modules/gdnative/include/gdnative/gdnative.h
index 9af9226a79..1937748bd4 100644
--- a/modules/gdnative/include/gdnative/gdnative.h
+++ b/modules/gdnative/include/gdnative/gdnative.h
@@ -161,9 +161,9 @@ typedef void godot_object;
 
 #include <gdnative/basis.h>
 
-/////// Transform
+/////// Transform3D
 
-#include <gdnative/transform.h>
+#include <gdnative/transform_3d.h>
 
 /////// Color
 
diff --git a/modules/gdnative/include/gdnative/transform.h b/modules/gdnative/include/gdnative/transform_3d.h
index 3861b5683a..97ad451e9b 100644
--- a/modules/gdnative/include/gdnative/transform.h
+++ b/modules/gdnative/include/gdnative/transform_3d.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  transform.h                                                          */
+/*  transform_3d.h                                                       */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,8 +28,8 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef GODOT_TRANSFORM_H
-#define GODOT_TRANSFORM_H
+#ifndef GODOT_TRANSFORM3D_H
+#define GODOT_TRANSFORM3D_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -37,22 +37,24 @@ extern "C" {
 
 #include <gdnative/math_defs.h>
 
-#define GODOT_TRANSFORM_SIZE (sizeof(godot_real_t) * 12)
+#define GODOT_TRANSFORM3D_SIZE (sizeof(godot_real_t) * 12)
 
-#ifndef GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED
-#define GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED
+#ifndef GODOT_CORE_API_GODOT_TRANSFORM3D_TYPE_DEFINED
+#define GODOT_CORE_API_GODOT_TRANSFORM3D_TYPE_DEFINED
 typedef struct {
-	uint8_t _dont_touch_that[GODOT_TRANSFORM_SIZE];
-} godot_transform;
+	uint8_t _dont_touch_that[GODOT_TRANSFORM3D_SIZE];
+} godot_transform3d;
 #endif
 
 #include <gdnative/gdnative.h>
 
-void GDAPI godot_transform_new(godot_transform *p_self);
-void GDAPI godot_transform_new_copy(godot_transform *r_dest, const godot_transform *p_src);
+void GDAPI godot_transform3d_new(godot_transform3d *p_self);
+void GDAPI godot_transform3d_new_copy(godot_transform3d *r_dest, const godot_transform3d *p_src);
+godot_vector3 GDAPI *godot_transform3d_operator_index(godot_transform3d *p_self, godot_int p_index);
+const godot_vector3 GDAPI *godot_transform3d_operator_index_const(const godot_transform3d *p_self, godot_int p_index);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // GODOT_TRANSFORM_H
+#endif // GODOT_TRANSFORM3D_H
diff --git a/modules/gdnative/include/gdnative/variant.h b/modules/gdnative/include/gdnative/variant.h
index 3e06ed9aa4..60392e0cd7 100644
--- a/modules/gdnative/include/gdnative/variant.h
+++ b/modules/gdnative/include/gdnative/variant.h
@@ -183,8 +183,8 @@ typedef void (*godot_ptr_utility_function)(void *r_return, const void **p_argume
 #include <gdnative/signal.h>
 #include <gdnative/string.h>
 #include <gdnative/string_name.h>
-#include <gdnative/transform.h>
 #include <gdnative/transform2d.h>
+#include <gdnative/transform_3d.h>
 #include <gdnative/variant.h>
 #include <gdnative/vector2.h>
 #include <gdnative/vector3.h>
@@ -211,7 +211,7 @@ void GDAPI godot_variant_new_plane(godot_variant *r_dest, const godot_plane *p_p
 void GDAPI godot_variant_new_quat(godot_variant *r_dest, const godot_quat *p_quat);
 void GDAPI godot_variant_new_aabb(godot_variant *r_dest, const godot_aabb *p_aabb);
 void GDAPI godot_variant_new_basis(godot_variant *r_dest, const godot_basis *p_basis);
-void GDAPI godot_variant_new_transform(godot_variant *r_dest, const godot_transform *p_trans);
+void GDAPI godot_variant_new_transform3d(godot_variant *r_dest, const godot_transform3d *p_trans);
 void GDAPI godot_variant_new_color(godot_variant *r_dest, const godot_color *p_color);
 void GDAPI godot_variant_new_string_name(godot_variant *r_dest, const godot_string_name *p_s);
 void GDAPI godot_variant_new_node_path(godot_variant *r_dest, const godot_node_path *p_np);
@@ -246,7 +246,7 @@ godot_plane GDAPI godot_variant_as_plane(const godot_variant *p_self);
 godot_quat GDAPI godot_variant_as_quat(const godot_variant *p_self);
 godot_aabb GDAPI godot_variant_as_aabb(const godot_variant *p_self);
 godot_basis GDAPI godot_variant_as_basis(const godot_variant *p_self);
-godot_transform GDAPI godot_variant_as_transform(const godot_variant *p_self);
+godot_transform3d GDAPI godot_variant_as_transform3d(const godot_variant *p_self);
 godot_color GDAPI godot_variant_as_color(const godot_variant *p_self);
 godot_string_name GDAPI godot_variant_as_string_name(const godot_variant *p_self);
 godot_node_path GDAPI godot_variant_as_node_path(const godot_variant *p_self);
diff --git a/modules/gdnative/include/xr/godot_xr.h b/modules/gdnative/include/xr/godot_xr.h
index 7eaf1c7ec3..e09244f3f9 100644
--- a/modules/gdnative/include/xr/godot_xr.h
+++ b/modules/gdnative/include/xr/godot_xr.h
@@ -57,7 +57,7 @@ typedef struct {
 	godot_bool (*initialize)(void *);
 	void (*uninitialize)(void *);
 	godot_vector2 (*get_render_targetsize)(const void *);
-	godot_transform (*get_transform_for_eye)(void *, godot_int, godot_transform *);
+	godot_transform3d (*get_transform_for_eye)(void *, godot_int, godot_transform3d *);
 	void (*fill_projection_for_eye)(void *, godot_float *, godot_int, godot_float, godot_float, godot_float);
 	void (*commit_for_eye)(void *, godot_int, godot_rid *, godot_rect2 *);
 	void (*process)(void *);
@@ -70,7 +70,7 @@ void GDAPI godot_xr_register_interface(const godot_xr_interface_gdnative *p_inte
 
 // helper functions to access XRServer data
 godot_float GDAPI godot_xr_get_worldscale();
-godot_transform GDAPI godot_xr_get_reference_frame();
+godot_transform3d GDAPI godot_xr_get_reference_frame();
 
 // helper functions for rendering
 void GDAPI godot_xr_blit(godot_int p_eye, godot_rid *p_render_target, godot_rect2 *p_rect);
@@ -79,7 +79,7 @@ godot_int GDAPI godot_xr_get_texid(godot_rid *p_render_target);
 // helper functions for updating XR controllers
 godot_int GDAPI godot_xr_add_controller(char *p_device_name, godot_int p_hand, godot_bool p_tracks_orientation, godot_bool p_tracks_position);
 void GDAPI godot_xr_remove_controller(godot_int p_controller_id);
-void GDAPI godot_xr_set_controller_transform(godot_int p_controller_id, godot_transform *p_transform, godot_bool p_tracks_orientation, godot_bool p_tracks_position);
+void GDAPI godot_xr_set_controller_transform(godot_int p_controller_id, godot_transform3d *p_transform, godot_bool p_tracks_orientation, godot_bool p_tracks_position);
 void GDAPI godot_xr_set_controller_button(godot_int p_controller_id, godot_int p_button, godot_bool p_is_pressed);
 void GDAPI godot_xr_set_controller_axis(godot_int p_controller_id, godot_int p_axis, godot_float p_value, godot_bool p_can_be_negative);
 godot_float GDAPI godot_xr_get_controller_rumble(godot_int p_controller_id);
diff --git a/modules/gdnative/register_types.cpp b/modules/gdnative/register_types.cpp
index d08bde9e23..cf19c0c44c 100644
--- a/modules/gdnative/register_types.cpp
+++ b/modules/gdnative/register_types.cpp
@@ -363,7 +363,7 @@ void unregister_gdnative_types() {
 	print_line(String("aabb:\t")     + itos(sizeof(AABB)));
 	print_line(String("rid:\t")       + itos(sizeof(RID)));
 	print_line(String("string:\t")    + itos(sizeof(String)));
-	print_line(String("transform:\t") + itos(sizeof(Transform)));
+	print_line(String("transform:\t") + itos(sizeof(Transform3D)));
 	print_line(String("transfo2D:\t") + itos(sizeof(Transform2D)));
 	print_line(String("variant:\t")   + itos(sizeof(Variant)));
 	print_line(String("vector2:\t")   + itos(sizeof(Vector2)));
diff --git a/modules/gdnative/xr/xr_interface_gdnative.cpp b/modules/gdnative/xr/xr_interface_gdnative.cpp
index 122cb5849b..258fb75000 100644
--- a/modules/gdnative/xr/xr_interface_gdnative.cpp
+++ b/modules/gdnative/xr/xr_interface_gdnative.cpp
@@ -173,14 +173,14 @@ Size2 XRInterfaceGDNative::get_render_targetsize() {
 	return *vec;
 }
 
-Transform XRInterfaceGDNative::get_transform_for_eye(XRInterface::Eyes p_eye, const Transform &p_cam_transform) {
-	Transform *ret;
+Transform3D XRInterfaceGDNative::get_transform_for_eye(XRInterface::Eyes p_eye, const Transform3D &p_cam_transform) {
+	Transform3D *ret;
 
-	ERR_FAIL_COND_V(interface == nullptr, Transform());
+	ERR_FAIL_COND_V(interface == nullptr, Transform3D());
 
-	godot_transform t = interface->get_transform_for_eye(data, (int)p_eye, (godot_transform *)&p_cam_transform);
+	godot_transform3d t = interface->get_transform_for_eye(data, (int)p_eye, (godot_transform3d *)&p_cam_transform);
 
-	ret = (Transform *)&t;
+	ret = (Transform3D *)&t;
 
 	return *ret;
 }
@@ -241,15 +241,15 @@ godot_float GDAPI godot_xr_get_worldscale() {
 	return xr_server->get_world_scale();
 }
 
-godot_transform GDAPI godot_xr_get_reference_frame() {
-	godot_transform reference_frame;
-	Transform *reference_frame_ptr = (Transform *)&reference_frame;
+godot_transform3d GDAPI godot_xr_get_reference_frame() {
+	godot_transform3d reference_frame;
+	Transform3D *reference_frame_ptr = (Transform3D *)&reference_frame;
 
 	XRServer *xr_server = XRServer::get_singleton();
 	if (xr_server != nullptr) {
 		*reference_frame_ptr = xr_server->get_reference_frame();
 	} else {
-		memnew_placement(&reference_frame, Transform);
+		memnew_placement(&reference_frame, Transform3D);
 	}
 
 	return reference_frame;
@@ -356,13 +356,13 @@ void GDAPI godot_xr_remove_controller(godot_int p_controller_id) {
 	}
 }
 
-void GDAPI godot_xr_set_controller_transform(godot_int p_controller_id, godot_transform *p_transform, godot_bool p_tracks_orientation, godot_bool p_tracks_position) {
+void GDAPI godot_xr_set_controller_transform(godot_int p_controller_id, godot_transform3d *p_transform, godot_bool p_tracks_orientation, godot_bool p_tracks_position) {
 	XRServer *xr_server = XRServer::get_singleton();
 	ERR_FAIL_NULL(xr_server);
 
 	Ref<XRPositionalTracker> tracker = xr_server->find_by_type_and_id(XRServer::TRACKER_CONTROLLER, p_controller_id);
 	if (tracker.is_valid()) {
-		Transform *transform = (Transform *)p_transform;
+		Transform3D *transform = (Transform3D *)p_transform;
 		if (p_tracks_orientation) {
 			tracker->set_orientation(transform->basis);
 		}
diff --git a/modules/gdnative/xr/xr_interface_gdnative.h b/modules/gdnative/xr/xr_interface_gdnative.h
index 84bd8fc731..42098ebeff 100644
--- a/modules/gdnative/xr/xr_interface_gdnative.h
+++ b/modules/gdnative/xr/xr_interface_gdnative.h
@@ -73,7 +73,7 @@ public:
 	/** rendering and internal **/
 	virtual Size2 get_render_targetsize() override;
 	virtual bool is_stereo() override;
-	virtual Transform get_transform_for_eye(XRInterface::Eyes p_eye, const Transform &p_cam_transform) override;
+	virtual Transform3D get_transform_for_eye(XRInterface::Eyes p_eye, const Transform3D &p_cam_transform) override;
 
 	// we expose a Vector<float> version of this function to GDNative
 	Vector<float> _get_projection_for_eye(XRInterface::Eyes p_eye, real_t p_aspect, real_t p_z_near, real_t p_z_far);
diff --git a/modules/gdnavigation/gd_navigation_server.cpp b/modules/gdnavigation/gd_navigation_server.cpp
index 88ef434e0f..d5e6e5e69f 100644
--- a/modules/gdnavigation/gd_navigation_server.cpp
+++ b/modules/gdnavigation/gd_navigation_server.cpp
@@ -270,7 +270,7 @@ COMMAND_2(region_set_map, RID, p_region, RID, p_map) {
 	}
 }
 
-COMMAND_2(region_set_transform, RID, p_region, Transform, p_transform) {
+COMMAND_2(region_set_transform, RID, p_region, Transform3D, p_transform) {
 	NavRegion *region = region_owner.getornull(p_region);
 	ERR_FAIL_COND(region == nullptr);
 
diff --git a/modules/gdnavigation/gd_navigation_server.h b/modules/gdnavigation/gd_navigation_server.h
index 2f51f6431e..759d15e508 100644
--- a/modules/gdnavigation/gd_navigation_server.h
+++ b/modules/gdnavigation/gd_navigation_server.h
@@ -113,7 +113,7 @@ public:
 	COMMAND_2(region_set_map, RID, p_region, RID, p_map);
 	COMMAND_2(region_set_layers, RID, p_region, uint32_t, p_layers);
 	virtual uint32_t region_get_layers(RID p_region) const;
-	COMMAND_2(region_set_transform, RID, p_region, Transform, p_transform);
+	COMMAND_2(region_set_transform, RID, p_region, Transform3D, p_transform);
 	COMMAND_2(region_set_navmesh, RID, p_region, Ref<NavigationMesh>, p_nav_mesh);
 	virtual void region_bake_navmesh(Ref<NavigationMesh> r_mesh, Node *p_node) const;
 	virtual int region_get_connections_count(RID p_region) const;
diff --git a/modules/gdnavigation/nav_region.cpp b/modules/gdnavigation/nav_region.cpp
index c1690b2a4b..81b15a49f5 100644
--- a/modules/gdnavigation/nav_region.cpp
+++ b/modules/gdnavigation/nav_region.cpp
@@ -52,7 +52,7 @@ uint32_t NavRegion::get_layers() const {
 	return layers;
 }
 
-void NavRegion::set_transform(Transform p_transform) {
+void NavRegion::set_transform(Transform3D p_transform) {
 	transform = p_transform;
 	polygons_dirty = true;
 }
diff --git a/modules/gdnavigation/nav_region.h b/modules/gdnavigation/nav_region.h
index 527b2500ac..f8b067e638 100644
--- a/modules/gdnavigation/nav_region.h
+++ b/modules/gdnavigation/nav_region.h
@@ -46,7 +46,7 @@ class NavRegion;
 
 class NavRegion : public NavRid {
 	NavMap *map = nullptr;
-	Transform transform;
+	Transform3D transform;
 	Ref<NavigationMesh> mesh;
 	uint32_t layers = 1;
 	Vector<gd::Edge::Connection> connections;
@@ -71,8 +71,8 @@ public:
 	void set_layers(uint32_t p_layers);
 	uint32_t get_layers() const;
 
-	void set_transform(Transform transform);
-	const Transform &get_transform() const {
+	void set_transform(Transform3D transform);
+	const Transform3D &get_transform() const {
 		return transform;
 	}
 
diff --git a/modules/gdnavigation/navigation_mesh_generator.cpp b/modules/gdnavigation/navigation_mesh_generator.cpp
index 7d30ce0f44..d69c9114b9 100644
--- a/modules/gdnavigation/navigation_mesh_generator.cpp
+++ b/modules/gdnavigation/navigation_mesh_generator.cpp
@@ -68,7 +68,7 @@ void NavigationMeshGenerator::_add_vertex(const Vector3 &p_vec3, Vector<float> &
 	p_verticies.push_back(p_vec3.z);
 }
 
-void NavigationMeshGenerator::_add_mesh(const Ref<Mesh> &p_mesh, const Transform &p_xform, Vector<float> &p_verticies, Vector<int> &p_indices) {
+void NavigationMeshGenerator::_add_mesh(const Ref<Mesh> &p_mesh, const Transform3D &p_xform, Vector<float> &p_verticies, Vector<int> &p_indices) {
 	int current_vertex_count;
 
 	for (int i = 0; i < p_mesh->get_surface_count(); i++) {
@@ -123,7 +123,7 @@ void NavigationMeshGenerator::_add_mesh(const Ref<Mesh> &p_mesh, const Transform
 	}
 }
 
-void NavigationMeshGenerator::_add_faces(const PackedVector3Array &p_faces, const Transform &p_xform, Vector<float> &p_verticies, Vector<int> &p_indices) {
+void NavigationMeshGenerator::_add_faces(const PackedVector3Array &p_faces, const Transform3D &p_xform, Vector<float> &p_verticies, Vector<int> &p_indices) {
 	int face_count = p_faces.size() / 3;
 	int current_vertex_count = p_verticies.size() / 3;
 
@@ -138,7 +138,7 @@ void NavigationMeshGenerator::_add_faces(const PackedVector3Array &p_faces, cons
 	}
 }
 
-void NavigationMeshGenerator::_parse_geometry(Transform p_accumulated_transform, Node *p_node, Vector<float> &p_verticies, Vector<int> &p_indices, int p_generate_from, uint32_t p_collision_mask, bool p_recurse_children) {
+void NavigationMeshGenerator::_parse_geometry(Transform3D p_accumulated_transform, Node *p_node, Vector<float> &p_verticies, Vector<int> &p_indices, int p_generate_from, uint32_t p_collision_mask, bool p_recurse_children) {
 	if (Object::cast_to<MeshInstance3D>(p_node) && p_generate_from != NavigationMesh::PARSED_GEOMETRY_STATIC_COLLIDERS) {
 		MeshInstance3D *mesh_instance = Object::cast_to<MeshInstance3D>(p_node);
 		Ref<Mesh> mesh = mesh_instance->get_mesh();
@@ -169,7 +169,7 @@ void NavigationMeshGenerator::_parse_geometry(Transform p_accumulated_transform,
 				if (Object::cast_to<CollisionShape3D>(child)) {
 					CollisionShape3D *col_shape = Object::cast_to<CollisionShape3D>(child);
 
-					Transform transform = p_accumulated_transform * static_body->get_transform() * col_shape->get_transform();
+					Transform3D transform = p_accumulated_transform * static_body->get_transform() * col_shape->get_transform();
 
 					Ref<Mesh> mesh;
 					Ref<Shape3D> s = col_shape->get_shape();
@@ -251,7 +251,7 @@ void NavigationMeshGenerator::_parse_geometry(Transform p_accumulated_transform,
 	if (Object::cast_to<GridMap>(p_node) && p_generate_from != NavigationMesh::PARSED_GEOMETRY_STATIC_COLLIDERS) {
 		GridMap *gridmap_instance = Object::cast_to<GridMap>(p_node);
 		Array meshes = gridmap_instance->get_meshes();
-		Transform xform = gridmap_instance->get_transform();
+		Transform3D xform = gridmap_instance->get_transform();
 		for (int i = 0; i < meshes.size(); i += 2) {
 			Ref<Mesh> mesh = meshes[i + 1];
 			if (mesh.is_valid()) {
@@ -513,7 +513,7 @@ void NavigationMeshGenerator::bake(Ref<NavigationMesh> p_nav_mesh, Node *p_node)
 		p_node->get_tree()->get_nodes_in_group(p_nav_mesh->get_source_group_name(), &parse_nodes);
 	}
 
-	Transform navmesh_xform = Object::cast_to<Node3D>(p_node)->get_transform().affine_inverse();
+	Transform3D navmesh_xform = Object::cast_to<Node3D>(p_node)->get_transform().affine_inverse();
 	for (const List<Node *>::Element *E = parse_nodes.front(); E; E = E->next()) {
 		int geometry_type = p_nav_mesh->get_parsed_geometry_type();
 		uint32_t collision_mask = p_nav_mesh->get_collision_mask();
diff --git a/modules/gdnavigation/navigation_mesh_generator.h b/modules/gdnavigation/navigation_mesh_generator.h
index 88ccdb1c41..847c7d097b 100644
--- a/modules/gdnavigation/navigation_mesh_generator.h
+++ b/modules/gdnavigation/navigation_mesh_generator.h
@@ -50,9 +50,9 @@ protected:
 	static void _bind_methods();
 
 	static void _add_vertex(const Vector3 &p_vec3, Vector<float> &p_verticies);
-	static void _add_mesh(const Ref<Mesh> &p_mesh, const Transform &p_xform, Vector<float> &p_verticies, Vector<int> &p_indices);
-	static void _add_faces(const PackedVector3Array &p_faces, const Transform &p_xform, Vector<float> &p_verticies, Vector<int> &p_indices);
-	static void _parse_geometry(Transform p_accumulated_transform, Node *p_node, Vector<float> &p_verticies, Vector<int> &p_indices, int p_generate_from, uint32_t p_collision_mask, bool p_recurse_children);
+	static void _add_mesh(const Ref<Mesh> &p_mesh, const Transform3D &p_xform, Vector<float> &p_verticies, Vector<int> &p_indices);
+	static void _add_faces(const PackedVector3Array &p_faces, const Transform3D &p_xform, Vector<float> &p_verticies, Vector<int> &p_indices);
+	static void _parse_geometry(Transform3D p_accumulated_transform, Node *p_node, Vector<float> &p_verticies, Vector<int> &p_indices, int p_generate_from, uint32_t p_collision_mask, bool p_recurse_children);
 
 	static void _convert_detail_mesh_to_native_navigation_mesh(const rcPolyMeshDetail *p_detail_mesh, Ref<NavigationMesh> p_nav_mesh);
 	static void _build_recast_navigation_mesh(
diff --git a/modules/gdscript/gdscript_analyzer.cpp b/modules/gdscript/gdscript_analyzer.cpp
index d8d60b35c6..a4786c5396 100644
--- a/modules/gdscript/gdscript_analyzer.cpp
+++ b/modules/gdscript/gdscript_analyzer.cpp
@@ -2836,8 +2836,8 @@ void GDScriptAnalyzer::reduce_subscript(GDScriptParser::SubscriptNode *p_subscri
 							case Variant::VECTOR2I:
 							case Variant::VECTOR3:
 							case Variant::VECTOR3I:
-							case Variant::TRANSFORM:
 							case Variant::TRANSFORM2D:
+							case Variant::TRANSFORM3D:
 								error = index_type.builtin_type != Variant::INT && index_type.builtin_type != Variant::FLOAT &&
 										index_type.builtin_type != Variant::STRING;
 								break;
@@ -2933,7 +2933,7 @@ void GDScriptAnalyzer::reduce_subscript(GDScriptParser::SubscriptNode *p_subscri
 						result_type.builtin_type = Variant::VECTOR3;
 						break;
 					// Depends on the index.
-					case Variant::TRANSFORM:
+					case Variant::TRANSFORM3D:
 					case Variant::PLANE:
 					case Variant::COLOR:
 					case Variant::DICTIONARY:
diff --git a/modules/gdscript/gdscript_byte_codegen.cpp b/modules/gdscript/gdscript_byte_codegen.cpp
index 77a972ef12..6d7d0951b0 100644
--- a/modules/gdscript/gdscript_byte_codegen.cpp
+++ b/modules/gdscript/gdscript_byte_codegen.cpp
@@ -88,7 +88,7 @@ uint32_t GDScriptByteCodeGenerator::add_temporary(const GDScriptDataType &p_type
 				case Variant::QUAT:
 				case Variant::AABB:
 				case Variant::BASIS:
-				case Variant::TRANSFORM:
+				case Variant::TRANSFORM3D:
 				case Variant::COLOR:
 				case Variant::STRING_NAME:
 				case Variant::NODE_PATH:
@@ -467,7 +467,7 @@ void GDScriptByteCodeGenerator::write_type_adjust(const Address &p_target, Varia
 		case Variant::BASIS:
 			append(GDScriptFunction::OPCODE_TYPE_ADJUST_BASIS, 1);
 			break;
-		case Variant::TRANSFORM:
+		case Variant::TRANSFORM3D:
 			append(GDScriptFunction::OPCODE_TYPE_ADJUST_TRANSFORM, 1);
 			break;
 		case Variant::COLOR:
@@ -1100,7 +1100,7 @@ void GDScriptByteCodeGenerator::write_call_ptrcall(const Address &p_target, cons
 			CASE_TYPE(PLANE);
 			CASE_TYPE(AABB);
 			CASE_TYPE(BASIS);
-			CASE_TYPE(TRANSFORM);
+			CASE_TYPE(TRANSFORM3D);
 			CASE_TYPE(COLOR);
 			CASE_TYPE(STRING_NAME);
 			CASE_TYPE(NODE_PATH);
diff --git a/modules/gdscript/gdscript_disassembler.cpp b/modules/gdscript/gdscript_disassembler.cpp
index eee713aa45..8aa64d7dcc 100644
--- a/modules/gdscript/gdscript_disassembler.cpp
+++ b/modules/gdscript/gdscript_disassembler.cpp
@@ -620,7 +620,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
 				DISASSEMBLE_PTRCALL(PLANE);
 				DISASSEMBLE_PTRCALL(AABB);
 				DISASSEMBLE_PTRCALL(BASIS);
-				DISASSEMBLE_PTRCALL(TRANSFORM);
+				DISASSEMBLE_PTRCALL(TRANSFORM3D);
 				DISASSEMBLE_PTRCALL(COLOR);
 				DISASSEMBLE_PTRCALL(STRING_NAME);
 				DISASSEMBLE_PTRCALL(NODE_PATH);
diff --git a/modules/gdscript/gdscript_function.h b/modules/gdscript/gdscript_function.h
index 26b8809337..658be9f364 100644
--- a/modules/gdscript/gdscript_function.h
+++ b/modules/gdscript/gdscript_function.h
@@ -281,7 +281,7 @@ public:
 		OPCODE_CALL_PTRCALL_QUAT,
 		OPCODE_CALL_PTRCALL_AABB,
 		OPCODE_CALL_PTRCALL_BASIS,
-		OPCODE_CALL_PTRCALL_TRANSFORM,
+		OPCODE_CALL_PTRCALL_TRANSFORM3D,
 		OPCODE_CALL_PTRCALL_COLOR,
 		OPCODE_CALL_PTRCALL_STRING_NAME,
 		OPCODE_CALL_PTRCALL_NODE_PATH,
diff --git a/modules/gdscript/gdscript_parser.cpp b/modules/gdscript/gdscript_parser.cpp
index b61b469fbc..152b1ba23c 100644
--- a/modules/gdscript/gdscript_parser.cpp
+++ b/modules/gdscript/gdscript_parser.cpp
@@ -63,7 +63,7 @@ Variant::Type GDScriptParser::get_builtin_type(const StringName &p_type) {
 		builtin_types["Plane"] = Variant::PLANE;
 		builtin_types["Quat"] = Variant::QUAT;
 		builtin_types["Basis"] = Variant::BASIS;
-		builtin_types["Transform"] = Variant::TRANSFORM;
+		builtin_types["Transform"] = Variant::TRANSFORM3D;
 		builtin_types["Color"] = Variant::COLOR;
 		builtin_types["RID"] = Variant::RID;
 		builtin_types["Object"] = Variant::OBJECT;
diff --git a/modules/gdscript/gdscript_vm.cpp b/modules/gdscript/gdscript_vm.cpp
index 56b0f6db83..d45d50287e 100644
--- a/modules/gdscript/gdscript_vm.cpp
+++ b/modules/gdscript/gdscript_vm.cpp
@@ -169,7 +169,7 @@ void (*type_init_function_table[])(Variant *) = {
 	&VariantInitializer<Quat>::init, // QUAT.
 	&VariantInitializer<AABB>::init, // AABB.
 	&VariantInitializer<Basis>::init, // BASIS.
-	&VariantInitializer<Transform>::init, // TRANSFORM.
+	&VariantInitializer<Transform3D>::init, // TRANSFORM3D.
 	&VariantInitializer<Color>::init, // COLOR.
 	&VariantInitializer<StringName>::init, // STRING_NAME.
 	&VariantInitializer<NodePath>::init, // NODE_PATH.
@@ -251,7 +251,7 @@ void (*type_init_function_table[])(Variant *) = {
 		&&OPCODE_CALL_PTRCALL_QUAT,                  \
 		&&OPCODE_CALL_PTRCALL_AABB,                  \
 		&&OPCODE_CALL_PTRCALL_BASIS,                 \
-		&&OPCODE_CALL_PTRCALL_TRANSFORM,             \
+		&&OPCODE_CALL_PTRCALL_TRANSFORM3D,           \
 		&&OPCODE_CALL_PTRCALL_COLOR,                 \
 		&&OPCODE_CALL_PTRCALL_STRING_NAME,           \
 		&&OPCODE_CALL_PTRCALL_NODE_PATH,             \
@@ -416,7 +416,7 @@ void (*type_init_function_table[])(Variant *) = {
 #define OP_GET_PACKED_VECTOR2_ARRAY get_vector2_array
 #define OP_GET_PACKED_VECTOR3_ARRAY get_vector3_array
 #define OP_GET_PACKED_COLOR_ARRAY get_color_array
-#define OP_GET_TRANSFORM get_transform
+#define OP_GET_TRANSFORM3D get_transform
 #define OP_GET_TRANSFORM2D get_transform2d
 #define OP_GET_PLANE get_plane
 #define OP_GET_AABB get_aabb
@@ -1736,7 +1736,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 			OPCODE_CALL_PTR(QUAT);
 			OPCODE_CALL_PTR(AABB);
 			OPCODE_CALL_PTR(BASIS);
-			OPCODE_CALL_PTR(TRANSFORM);
+			OPCODE_CALL_PTR(TRANSFORM3D);
 			OPCODE_CALL_PTR(COLOR);
 			OPCODE_CALL_PTR(STRING_NAME);
 			OPCODE_CALL_PTR(NODE_PATH);
@@ -3153,7 +3153,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 			OPCODE_TYPE_ADJUST(QUAT, Quat);
 			OPCODE_TYPE_ADJUST(AABB, AABB);
 			OPCODE_TYPE_ADJUST(BASIS, Basis);
-			OPCODE_TYPE_ADJUST(TRANSFORM, Transform);
+			OPCODE_TYPE_ADJUST(TRANSFORM, Transform3D);
 			OPCODE_TYPE_ADJUST(COLOR, Color);
 			OPCODE_TYPE_ADJUST(STRING_NAME, StringName);
 			OPCODE_TYPE_ADJUST(NODE_PATH, NodePath);
diff --git a/modules/gltf/doc_classes/GLTFNode.xml b/modules/gltf/doc_classes/GLTFNode.xml
index af7be55e4b..33aad0028e 100644
--- a/modules/gltf/doc_classes/GLTFNode.xml
+++ b/modules/gltf/doc_classes/GLTFNode.xml
@@ -33,7 +33,7 @@
 		</member>
 		<member name="translation" type="Vector3" setter="set_translation" getter="get_translation" default="Vector3( 0, 0, 0 )">
 		</member>
-		<member name="xform" type="Transform" setter="set_xform" getter="get_xform" default="Transform( 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 )">
+		<member name="xform" type="Transform3D" setter="set_xform" getter="get_xform" default="Transform3D( 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 )">
 		</member>
 	</members>
 	<constants>
diff --git a/modules/gltf/gltf_document.cpp b/modules/gltf/gltf_document.cpp
index abac0a2e17..6ca1c357c2 100644
--- a/modules/gltf/gltf_document.cpp
+++ b/modules/gltf/gltf_document.cpp
@@ -357,10 +357,10 @@ static Quat _arr_to_quat(const Array &p_array) {
 	return Quat(p_array[0], p_array[1], p_array[2], p_array[3]);
 }
 
-static Transform _arr_to_xform(const Array &p_array) {
-	ERR_FAIL_COND_V(p_array.size() != 16, Transform());
+static Transform3D _arr_to_xform(const Array &p_array) {
+	ERR_FAIL_COND_V(p_array.size() != 16, Transform3D());
 
-	Transform xform;
+	Transform3D xform;
 	xform.basis.set_axis(Vector3::AXIS_X, Vector3(p_array[0], p_array[1], p_array[2]));
 	xform.basis.set_axis(Vector3::AXIS_Y, Vector3(p_array[4], p_array[5], p_array[6]));
 	xform.basis.set_axis(Vector3::AXIS_Z, Vector3(p_array[8], p_array[9], p_array[10]));
@@ -369,7 +369,7 @@ static Transform _arr_to_xform(const Array &p_array) {
 	return xform;
 }
 
-static Vector<real_t> _xform_to_array(const Transform p_transform) {
+static Vector<real_t> _xform_to_array(const Transform3D p_transform) {
 	Vector<real_t> array;
 	array.resize(16);
 	Vector3 axis_x = p_transform.get_basis().get_axis(Vector3::AXIS_X);
@@ -421,7 +421,7 @@ Error GLTFDocument::_serialize_nodes(Ref<GLTFState> state) {
 		}
 		if (n->skeleton != -1 && n->skin < 0) {
 		}
-		if (n->xform != Transform()) {
+		if (n->xform != Transform3D()) {
 			node["matrix"] = _xform_to_array(n->xform);
 		}
 
@@ -1939,7 +1939,7 @@ GLTFAccessorIndex GLTFDocument::_encode_accessor_as_vec3(Ref<GLTFState> state, c
 	return state->accessors.size() - 1;
 }
 
-GLTFAccessorIndex GLTFDocument::_encode_accessor_as_xform(Ref<GLTFState> state, const Vector<Transform> p_attribs, const bool p_for_vertex) {
+GLTFAccessorIndex GLTFDocument::_encode_accessor_as_xform(Ref<GLTFState> state, const Vector<Transform3D> p_attribs, const bool p_for_vertex) {
 	if (p_attribs.size() == 0) {
 		return -1;
 	}
@@ -1953,7 +1953,7 @@ GLTFAccessorIndex GLTFDocument::_encode_accessor_as_xform(Ref<GLTFState> state,
 	Vector<double> type_min;
 	type_min.resize(element_count);
 	for (int i = 0; i < p_attribs.size(); i++) {
-		Transform attrib = p_attribs[i];
+		Transform3D attrib = p_attribs[i];
 		Basis basis = attrib.get_basis();
 		Vector3 axis_0 = basis.get_axis(Vector3::AXIS_X);
 
@@ -2107,9 +2107,9 @@ Vector<Basis> GLTFDocument::_decode_accessor_as_basis(Ref<GLTFState> state, cons
 	return ret;
 }
 
-Vector<Transform> GLTFDocument::_decode_accessor_as_xform(Ref<GLTFState> state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {
+Vector<Transform3D> GLTFDocument::_decode_accessor_as_xform(Ref<GLTFState> state, const GLTFAccessorIndex p_accessor, const bool p_for_vertex) {
 	const Vector<double> attribs = _decode_accessor(state, p_accessor, p_for_vertex);
-	Vector<Transform> ret;
+	Vector<Transform3D> ret;
 
 	if (attribs.size() == 0) {
 		return ret;
@@ -4279,7 +4279,7 @@ Error GLTFDocument::_create_skins(Ref<GLTFState> state) {
 			GLTFNodeIndex node = gltf_skin->joints_original[joint_i];
 			String bone_name = state->nodes[node]->get_name();
 
-			Transform xform;
+			Transform3D xform;
 			if (has_ibms) {
 				xform = gltf_skin->inverse_binds[joint_i];
 			}
@@ -4323,8 +4323,8 @@ bool GLTFDocument::_skins_are_same(const Ref<Skin> skin_a, const Ref<Skin> skin_
 			return false;
 		}
 
-		Transform a_xform = skin_a->get_bind_pose(i);
-		Transform b_xform = skin_b->get_bind_pose(i);
+		Transform3D a_xform = skin_a->get_bind_pose(i);
+		Transform3D b_xform = skin_b->get_bind_pose(i);
 
 		if (a_xform != b_xform) {
 			return false;
@@ -5075,7 +5075,7 @@ GLTFSkeletonIndex GLTFDocument::_convert_skeleton(Ref<GLTFState> state, Skeleton
 }
 
 void GLTFDocument::_convert_spatial(Ref<GLTFState> state, Node3D *p_spatial, Ref<GLTFNode> p_node) {
-	Transform xform = p_spatial->get_transform();
+	Transform3D xform = p_spatial->get_transform();
 	p_node->scale = xform.basis.get_scale();
 	p_node->rotation = xform.basis.get_rotation_quat();
 	p_node->translation = xform.origin;
@@ -5240,7 +5240,7 @@ void GLTFDocument::_convert_grid_map_to_gltf(Node *p_scene_parent, const GLTFNod
 				Vector3(cell_location.x, cell_location.y, cell_location.z));
 		EditorSceneImporterMeshNode3D *import_mesh_node = memnew(EditorSceneImporterMeshNode3D);
 		import_mesh_node->set_mesh(grid_map->get_mesh_library()->get_item_mesh(cell));
-		Transform cell_xform;
+		Transform3D cell_xform;
 		cell_xform.basis.set_orthogonal_index(
 				grid_map->get_cell_item_orientation(
 						Vector3(cell_location.x, cell_location.y, cell_location.z)));
@@ -5268,7 +5268,7 @@ void GLTFDocument::_convert_mult_mesh_instance_to_gltf(Node *p_scene_parent, con
 		for (int32_t instance_i = 0; instance_i < multi_mesh->get_instance_count();
 				instance_i++) {
 			GLTFNode *new_gltf_node = memnew(GLTFNode);
-			Transform transform;
+			Transform3D transform;
 			if (multi_mesh->get_transform_format() == MultiMesh::TRANSFORM_2D) {
 				Transform2D xform_2d = multi_mesh->get_instance_transform_2d(instance_i);
 				transform.origin =
@@ -5715,7 +5715,7 @@ void GLTFDocument::_import_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 				}
 
 				if (gltf_node->skeleton >= 0) {
-					Transform xform;
+					Transform3D xform;
 					xform.basis.set_quat_scale(rot, scale);
 					xform.origin = pos;
 
@@ -5808,7 +5808,7 @@ void GLTFDocument::_convert_mesh_instances(Ref<GLTFState> state) {
 		}
 		MeshInstance3D *mi = Object::cast_to<MeshInstance3D>(mi_element->get());
 		ERR_CONTINUE(!mi);
-		Transform mi_xform = mi->get_transform();
+		Transform3D mi_xform = mi->get_transform();
 		node->scale = mi_xform.basis.get_scale();
 		node->rotation = mi_xform.basis.get_rotation_quat();
 		node->translation = mi_xform.origin;
@@ -5872,7 +5872,7 @@ void GLTFDocument::_convert_mesh_instances(Ref<GLTFState> state) {
 			String gltf_bone_name = _gen_unique_bone_name(state, skeleton_gltf_i, godot_bone_name);
 			joint_node->set_name(gltf_bone_name);
 
-			Transform bone_rest_xform = skeleton->get_bone_rest(bone_index);
+			Transform3D bone_rest_xform = skeleton->get_bone_rest(bone_index);
 			joint_node->scale = bone_rest_xform.basis.get_scale();
 			joint_node->rotation = bone_rest_xform.basis.get_rotation_quat();
 			joint_node->translation = bone_rest_xform.origin;
@@ -5995,12 +5995,12 @@ void GLTFDocument::_process_mesh_instances(Ref<GLTFState> state, Node *scene_roo
 
 			mi->set_skin(state->skins.write[skin_i]->godot_skin);
 			mi->set_skeleton_path(mi->get_path_to(skeleton));
-			mi->set_transform(Transform());
+			mi->set_transform(Transform3D());
 		}
 	}
 }
 
-GLTFAnimation::Track GLTFDocument::_convert_animation_track(Ref<GLTFState> state, GLTFAnimation::Track p_track, Ref<Animation> p_animation, Transform p_bone_rest, int32_t p_track_i, GLTFNodeIndex p_node_i) {
+GLTFAnimation::Track GLTFDocument::_convert_animation_track(Ref<GLTFState> state, GLTFAnimation::Track p_track, Ref<Animation> p_animation, Transform3D p_bone_rest, int32_t p_track_i, GLTFNodeIndex p_node_i) {
 	Animation::InterpolationType interpolation = p_animation->track_get_interpolation_type(p_track_i);
 
 	GLTFAnimation::Interpolation gltf_interpolation = GLTFAnimation::INTERP_LINEAR;
@@ -6040,7 +6040,7 @@ GLTFAnimation::Track GLTFDocument::_convert_animation_track(Ref<GLTFState> state
 			Vector3 scale;
 			Error err = p_animation->transform_track_get_key(p_track_i, key_i, &translation, &rotation, &scale);
 			ERR_CONTINUE(err != OK);
-			Transform xform;
+			Transform3D xform;
 			xform.basis.set_quat_scale(rotation, scale);
 			xform.origin = translation;
 			xform = p_bone_rest * xform;
@@ -6063,7 +6063,7 @@ GLTFAnimation::Track GLTFDocument::_convert_animation_track(Ref<GLTFState> state
 		p_track.rotation_track.values.resize(key_count);
 		p_track.rotation_track.interpolation = gltf_interpolation;
 		for (int32_t key_i = 0; key_i < key_count; key_i++) {
-			Transform xform = p_animation->track_get_key_value(p_track_i, key_i);
+			Transform3D xform = p_animation->track_get_key_value(p_track_i, key_i);
 			p_track.translation_track.values.write[key_i] = xform.get_origin();
 			p_track.rotation_track.values.write[key_i] = xform.basis.get_rotation_quat();
 			p_track.scale_track.values.write[key_i] = xform.basis.get_scale();
@@ -6210,7 +6210,7 @@ void GLTFDocument::_convert_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 					if (translation_track_i) {
 						track = translation_track_i->get();
 					}
-					track = _convert_animation_track(state, track, animation, Transform(), track_i, node_index);
+					track = _convert_animation_track(state, track, animation, Transform3D(), track_i, node_index);
 					gltf_animation->get_tracks().insert(node_index, track);
 				}
 			}
@@ -6226,7 +6226,7 @@ void GLTFDocument::_convert_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 					if (rotation_degree_track_i) {
 						track = rotation_degree_track_i->get();
 					}
-					track = _convert_animation_track(state, track, animation, Transform(), track_i, node_index);
+					track = _convert_animation_track(state, track, animation, Transform3D(), track_i, node_index);
 					gltf_animation->get_tracks().insert(node_index, track);
 				}
 			}
@@ -6242,7 +6242,7 @@ void GLTFDocument::_convert_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 					if (scale_track_i) {
 						track = scale_track_i->get();
 					}
-					track = _convert_animation_track(state, track, animation, Transform(), track_i, node_index);
+					track = _convert_animation_track(state, track, animation, Transform3D(), track_i, node_index);
 					gltf_animation->get_tracks().insert(node_index, track);
 				}
 			}
@@ -6253,7 +6253,7 @@ void GLTFDocument::_convert_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 			for (Map<GLTFNodeIndex, Node *>::Element *transform_track_i = state->scene_nodes.front(); transform_track_i; transform_track_i = transform_track_i->next()) {
 				if (transform_track_i->get() == node) {
 					GLTFAnimation::Track track;
-					track = _convert_animation_track(state, track, animation, Transform(), track_i, transform_track_i->key());
+					track = _convert_animation_track(state, track, animation, Transform3D(), track_i, transform_track_i->key());
 					gltf_animation->get_tracks().insert(transform_track_i->key(), track);
 				}
 			}
@@ -6341,7 +6341,7 @@ void GLTFDocument::_convert_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 					Ref<GLTFSkeleton> skeleton_gltf = state->skeletons[skeleton_gltf_i];
 					int32_t bone = skeleton->find_bone(suffix);
 					ERR_CONTINUE(bone == -1);
-					Transform xform = skeleton->get_bone_rest(bone);
+					Transform3D xform = skeleton->get_bone_rest(bone);
 					if (!skeleton_gltf->godot_bone_node.has(bone)) {
 						continue;
 					}
@@ -6368,7 +6368,7 @@ void GLTFDocument::_convert_animation(Ref<GLTFState> state, AnimationPlayer *ap,
 						if (node_track_i) {
 							track = node_track_i->get();
 						}
-						track = _convert_animation_track(state, track, animation, Transform(), track_i, node_index);
+						track = _convert_animation_track(state, track, animation, Transform3D(), track_i, node_index);
 						gltf_animation->get_tracks().insert(node_index, track);
 						break;
 					}
diff --git a/modules/gltf/gltf_document.h b/modules/gltf/gltf_document.h
index 900c367010..3076ddb8ad 100644
--- a/modules/gltf/gltf_document.h
+++ b/modules/gltf/gltf_document.h
@@ -214,7 +214,7 @@ private:
 	Vector<Basis> _decode_accessor_as_basis(Ref<GLTFState> state,
 			const GLTFAccessorIndex p_accessor,
 			const bool p_for_vertex);
-	Vector<Transform> _decode_accessor_as_xform(Ref<GLTFState> state,
+	Vector<Transform3D> _decode_accessor_as_xform(Ref<GLTFState> state,
 			const GLTFAccessorIndex p_accessor,
 			const bool p_for_vertex);
 	Error _parse_meshes(Ref<GLTFState> state);
@@ -317,7 +317,7 @@ private:
 			const Vector<int32_t> p_attribs,
 			const bool p_for_vertex);
 	GLTFAccessorIndex _encode_accessor_as_xform(Ref<GLTFState> state,
-			const Vector<Transform> p_attribs,
+			const Vector<Transform3D> p_attribs,
 			const bool p_for_vertex);
 	Error _encode_buffer_view(Ref<GLTFState> state, const double *src,
 			const int count, const GLTFType type,
@@ -333,7 +333,7 @@ private:
 	String interpolation_to_string(const GLTFAnimation::Interpolation p_interp);
 	GLTFAnimation::Track _convert_animation_track(Ref<GLTFState> state,
 			GLTFAnimation::Track p_track,
-			Ref<Animation> p_animation, Transform p_bone_rest,
+			Ref<Animation> p_animation, Transform3D p_bone_rest,
 			int32_t p_track_i,
 			GLTFNodeIndex p_node_i);
 	Error _encode_buffer_bins(Ref<GLTFState> state, const String &p_path);
diff --git a/modules/gltf/gltf_node.cpp b/modules/gltf/gltf_node.cpp
index f6f33ef009..759b52619d 100644
--- a/modules/gltf/gltf_node.cpp
+++ b/modules/gltf/gltf_node.cpp
@@ -60,7 +60,7 @@ void GLTFNode::_bind_methods() {
 
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "parent"), "set_parent", "get_parent"); // GLTFNodeIndex
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "height"), "set_height", "get_height"); // int
-	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM, "xform"), "set_xform", "get_xform"); // Transform
+	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM3D, "xform"), "set_xform", "get_xform"); // Transform3D
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "mesh"), "set_mesh", "get_mesh"); // GLTFMeshIndex
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "camera"), "set_camera", "get_camera"); // GLTFCameraIndex
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "skin"), "set_skin", "get_skin"); // GLTFSkinIndex
@@ -89,11 +89,11 @@ void GLTFNode::set_height(int p_height) {
 	height = p_height;
 }
 
-Transform GLTFNode::get_xform() {
+Transform3D GLTFNode::get_xform() {
 	return xform;
 }
 
-void GLTFNode::set_xform(Transform p_xform) {
+void GLTFNode::set_xform(Transform3D p_xform) {
 	xform = p_xform;
 }
 
diff --git a/modules/gltf/gltf_node.h b/modules/gltf/gltf_node.h
index 3a5689d004..6e6d9d5248 100644
--- a/modules/gltf/gltf_node.h
+++ b/modules/gltf/gltf_node.h
@@ -43,7 +43,7 @@ private:
 	// matrices need to be transformed to this
 	GLTFNodeIndex parent = -1;
 	int height = -1;
-	Transform xform;
+	Transform3D xform;
 	GLTFMeshIndex mesh = -1;
 	GLTFCameraIndex camera = -1;
 	GLTFSkinIndex skin = -1;
@@ -65,8 +65,8 @@ public:
 	int get_height();
 	void set_height(int p_height);
 
-	Transform get_xform();
-	void set_xform(Transform p_xform);
+	Transform3D get_xform();
+	void set_xform(Transform3D p_xform);
 
 	GLTFMeshIndex get_mesh();
 	void set_mesh(GLTFMeshIndex p_mesh);
diff --git a/modules/gltf/gltf_skin.cpp b/modules/gltf/gltf_skin.cpp
index 5a61e5778c..5cf17135ac 100644
--- a/modules/gltf/gltf_skin.cpp
+++ b/modules/gltf/gltf_skin.cpp
@@ -54,7 +54,7 @@ void GLTFSkin::_bind_methods() {
 
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "skin_root"), "set_skin_root", "get_skin_root"); // GLTFNodeIndex
 	ADD_PROPERTY(PropertyInfo(Variant::PACKED_INT32_ARRAY, "joints_original"), "set_joints_original", "get_joints_original"); // Vector<GLTFNodeIndex>
-	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "inverse_binds", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_INTERNAL), "set_inverse_binds", "get_inverse_binds"); // Vector<Transform>
+	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "inverse_binds", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_INTERNAL), "set_inverse_binds", "get_inverse_binds"); // Vector<Transform3D>
 	ADD_PROPERTY(PropertyInfo(Variant::PACKED_INT32_ARRAY, "joints"), "set_joints", "get_joints"); // Vector<GLTFNodeIndex>
 	ADD_PROPERTY(PropertyInfo(Variant::PACKED_INT32_ARRAY, "non_joints"), "set_non_joints", "get_non_joints"); // Vector<GLTFNodeIndex>
 	ADD_PROPERTY(PropertyInfo(Variant::PACKED_INT32_ARRAY, "roots"), "set_roots", "get_roots"); // Vector<GLTFNodeIndex>
diff --git a/modules/gltf/gltf_skin.h b/modules/gltf/gltf_skin.h
index 7cc09d85bc..e32e2d397c 100644
--- a/modules/gltf/gltf_skin.h
+++ b/modules/gltf/gltf_skin.h
@@ -43,7 +43,7 @@ private:
 	GLTFNodeIndex skin_root = -1;
 
 	Vector<GLTFNodeIndex> joints_original;
-	Vector<Transform> inverse_binds;
+	Vector<Transform3D> inverse_binds;
 
 	// Note: joints + non_joints should form a complete subtree, or subtrees
 	// with a common parent
diff --git a/modules/gridmap/doc_classes/GridMap.xml b/modules/gridmap/doc_classes/GridMap.xml
index 9b6fa138e5..fb0a2c9953 100644
--- a/modules/gridmap/doc_classes/GridMap.xml
+++ b/modules/gridmap/doc_classes/GridMap.xml
@@ -41,7 +41,7 @@
 			<return type="Array">
 			</return>
 			<description>
-				Returns an array of [ArrayMesh]es and [Transform] references of all bake meshes that exist within the current GridMap.
+				Returns an array of [ArrayMesh]es and [Transform3D] references of all bake meshes that exist within the current GridMap.
 			</description>
 		</method>
 		<method name="get_cell_item" qualifiers="const">
@@ -84,7 +84,7 @@
 			<return type="Array">
 			</return>
 			<description>
-				Returns an array of [Transform] and [Mesh] references corresponding to the non-empty cells in the grid. The transforms are specified in world space.
+				Returns an array of [Transform3D] and [Mesh] references corresponding to the non-empty cells in the grid. The transforms are specified in world space.
 			</description>
 		</method>
 		<method name="get_used_cells" qualifiers="const">
diff --git a/modules/gridmap/grid_map.cpp b/modules/gridmap/grid_map.cpp
index eaceaac33c..45af59622f 100644
--- a/modules/gridmap/grid_map.cpp
+++ b/modules/gridmap/grid_map.cpp
@@ -446,7 +446,7 @@ bool GridMap::_octant_update(const OctantKey &p_key) {
 	 * and set said multimesh bounding box to one containing all cells which have this item
 	 */
 
-	Map<int, List<Pair<Transform, IndexKey>>> multimesh_items;
+	Map<int, List<Pair<Transform3D, IndexKey>>> multimesh_items;
 
 	for (Set<IndexKey>::Element *E = g.cells.front(); E; E = E->next()) {
 		ERR_CONTINUE(!cell_map.has(E->get()));
@@ -459,7 +459,7 @@ bool GridMap::_octant_update(const OctantKey &p_key) {
 		Vector3 cellpos = Vector3(E->get().x, E->get().y, E->get().z);
 		Vector3 ofs = _get_offset();
 
-		Transform xform;
+		Transform3D xform;
 
 		xform.basis.set_orthogonal_index(c.rot);
 		xform.set_origin(cellpos * cell_size + ofs);
@@ -467,10 +467,10 @@ bool GridMap::_octant_update(const OctantKey &p_key) {
 		if (baked_meshes.size() == 0) {
 			if (mesh_library->get_item_mesh(c.item).is_valid()) {
 				if (!multimesh_items.has(c.item)) {
-					multimesh_items[c.item] = List<Pair<Transform, IndexKey>>();
+					multimesh_items[c.item] = List<Pair<Transform3D, IndexKey>>();
 				}
 
-				Pair<Transform, IndexKey> p;
+				Pair<Transform3D, IndexKey> p;
 				p.first = xform;
 				p.second = E->get();
 				multimesh_items[c.item].push_back(p);
@@ -511,7 +511,7 @@ bool GridMap::_octant_update(const OctantKey &p_key) {
 
 	//update multimeshes, only if not baked
 	if (baked_meshes.size() == 0) {
-		for (Map<int, List<Pair<Transform, IndexKey>>>::Element *E = multimesh_items.front(); E; E = E->next()) {
+		for (Map<int, List<Pair<Transform3D, IndexKey>>>::Element *E = multimesh_items.front(); E; E = E->next()) {
 			Octant::MultimeshInstance mmi;
 
 			RID mm = RS::get_singleton()->multimesh_create();
@@ -519,7 +519,7 @@ bool GridMap::_octant_update(const OctantKey &p_key) {
 			RS::get_singleton()->multimesh_set_mesh(mm, mesh_library->get_item_mesh(E->key())->get_rid());
 
 			int idx = 0;
-			for (List<Pair<Transform, IndexKey>>::Element *F = E->get().front(); F; F = F->next()) {
+			for (List<Pair<Transform3D, IndexKey>>::Element *F = E->get().front(); F; F = F->next()) {
 				RS::get_singleton()->multimesh_instance_set_transform(mm, idx, F->get().first);
 #ifdef TOOLS_ENABLED
 
@@ -672,7 +672,7 @@ void GridMap::_notification(int p_what) {
 
 		} break;
 		case NOTIFICATION_TRANSFORM_CHANGED: {
-			Transform new_xform = get_global_transform();
+			Transform3D new_xform = get_global_transform();
 			if (new_xform == last_transform) {
 				break;
 			}
@@ -686,7 +686,6 @@ void GridMap::_notification(int p_what) {
 			for (int i = 0; i < baked_meshes.size(); i++) {
 				RS::get_singleton()->instance_set_transform(baked_meshes[i].instance, get_global_transform());
 			}
-
 		} break;
 		case NOTIFICATION_EXIT_WORLD: {
 			for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
@@ -934,7 +933,7 @@ Array GridMap::get_meshes() {
 
 		Vector3 cellpos = Vector3(ik.x, ik.y, ik.z);
 
-		Transform xform;
+		Transform3D xform;
 
 		xform.basis.set_orthogonal_index(E->get().rot);
 
@@ -988,7 +987,7 @@ void GridMap::make_baked_meshes(bool p_gen_lightmap_uv, float p_lightmap_uv_texe
 		Vector3 cellpos = Vector3(key.x, key.y, key.z);
 		Vector3 ofs = _get_offset();
 
-		Transform xform;
+		Transform3D xform;
 
 		xform.basis.set_orthogonal_index(E->get().rot);
 		xform.set_origin(cellpos * cell_size + ofs);
@@ -1057,7 +1056,7 @@ Array GridMap::get_bake_meshes() {
 	Array arr;
 	for (int i = 0; i < baked_meshes.size(); i++) {
 		arr.push_back(baked_meshes[i].mesh);
-		arr.push_back(Transform());
+		arr.push_back(Transform3D());
 	}
 
 	return arr;
diff --git a/modules/gridmap/grid_map.h b/modules/gridmap/grid_map.h
index 4c04d492f7..8cd82e1f4c 100644
--- a/modules/gridmap/grid_map.h
+++ b/modules/gridmap/grid_map.h
@@ -89,7 +89,7 @@ class GridMap : public Node3D {
 	struct Octant {
 		struct NavMesh {
 			RID region;
-			Transform xform;
+			Transform3D xform;
 		};
 
 		struct MultimeshInstance {
@@ -97,7 +97,7 @@ class GridMap : public Node3D {
 			RID multimesh;
 			struct Item {
 				int index = 0;
-				Transform transform;
+				Transform3D transform;
 				IndexKey key;
 			};
 
@@ -137,7 +137,7 @@ class GridMap : public Node3D {
 	bool bake_navigation = false;
 	uint32_t navigation_layers = 1;
 
-	Transform last_transform;
+	Transform3D last_transform;
 
 	bool _in_tree = false;
 	Vector3 cell_size = Vector3(2, 2, 2);
diff --git a/modules/gridmap/grid_map_editor_plugin.cpp b/modules/gridmap/grid_map_editor_plugin.cpp
index 813b4b9689..a47ed6652d 100644
--- a/modules/gridmap/grid_map_editor_plugin.cpp
+++ b/modules/gridmap/grid_map_editor_plugin.cpp
@@ -255,7 +255,7 @@ void GridMapEditor::_menu_option(int p_option) {
 }
 
 void GridMapEditor::_update_cursor_transform() {
-	cursor_transform = Transform();
+	cursor_transform = Transform3D();
 	cursor_transform.origin = cursor_origin;
 	cursor_transform.basis.set_orthogonal_index(cursor_rot);
 	cursor_transform.basis *= node->get_cell_scale();
@@ -268,7 +268,7 @@ void GridMapEditor::_update_cursor_transform() {
 }
 
 void GridMapEditor::_update_selection_transform() {
-	Transform xf_zero;
+	Transform3D xf_zero;
 	xf_zero.basis.set_zero();
 
 	if (!selection.active) {
@@ -279,7 +279,7 @@ void GridMapEditor::_update_selection_transform() {
 		return;
 	}
 
-	Transform xf;
+	Transform3D xf;
 	xf.scale((Vector3(1, 1, 1) + (selection.end - selection.begin)) * node->get_cell_size());
 	xf.origin = selection.begin * node->get_cell_size();
 
@@ -297,7 +297,7 @@ void GridMapEditor::_update_selection_transform() {
 			scale *= node->get_cell_size();
 			position *= node->get_cell_size();
 
-			Transform xf2;
+			Transform3D xf2;
 			xf2.basis.scale(scale);
 			xf2.origin = position;
 
@@ -362,7 +362,7 @@ bool GridMapEditor::do_input_action(Camera3D *p_camera, const Point2 &p_point, b
 	Camera3D *camera = p_camera;
 	Vector3 from = camera->project_ray_origin(p_point);
 	Vector3 normal = camera->project_ray_normal(p_point);
-	Transform local_xform = node->get_global_transform().affine_inverse();
+	Transform3D local_xform = node->get_global_transform().affine_inverse();
 	Vector<Plane> planes = camera->get_frustum();
 	from = local_xform.xform(from);
 	normal = local_xform.basis.xform(normal).normalized();
@@ -540,7 +540,7 @@ void GridMapEditor::_set_clipboard_data() {
 
 void GridMapEditor::_update_paste_indicator() {
 	if (input_action != INPUT_PASTE) {
-		Transform xf;
+		Transform3D xf;
 		xf.basis.set_zero();
 		RenderingServer::get_singleton()->instance_set_transform(paste_instance, xf);
 		return;
@@ -548,7 +548,7 @@ void GridMapEditor::_update_paste_indicator() {
 
 	Vector3 center = 0.5 * Vector3(real_t(node->get_center_x()), real_t(node->get_center_y()), real_t(node->get_center_z()));
 	Vector3 scale = (Vector3(1, 1, 1) + (paste_indicator.end - paste_indicator.begin)) * node->get_cell_size();
-	Transform xf;
+	Transform3D xf;
 	xf.scale(scale);
 	xf.origin = (paste_indicator.begin + (paste_indicator.current - paste_indicator.click) + center) * node->get_cell_size();
 	Basis rot;
@@ -561,7 +561,7 @@ void GridMapEditor::_update_paste_indicator() {
 	for (List<ClipboardItem>::Element *E = clipboard_items.front(); E; E = E->next()) {
 		ClipboardItem &item = E->get();
 
-		xf = Transform();
+		xf = Transform3D();
 		xf.origin = (paste_indicator.begin + (paste_indicator.current - paste_indicator.click) + center) * node->get_cell_size();
 		xf.basis = rot * xf.basis;
 		xf.translate(item.grid_offset * node->get_cell_size());
@@ -1068,7 +1068,7 @@ void GridMapEditor::_notification(int p_what) {
 				return;
 			}
 
-			Transform xf = node->get_global_transform();
+			Transform3D xf = node->get_global_transform();
 
 			if (xf != grid_xform) {
 				for (int i = 0; i < 3; i++) {
diff --git a/modules/gridmap/grid_map_editor_plugin.h b/modules/gridmap/grid_map_editor_plugin.h
index 6c7f0bedf6..0e29c88d26 100644
--- a/modules/gridmap/grid_map_editor_plugin.h
+++ b/modules/gridmap/grid_map_editor_plugin.h
@@ -95,8 +95,8 @@ class GridMapEditor : public VBoxContainer {
 	ClipMode clip_mode = CLIP_DISABLED;
 
 	bool lock_view = false;
-	Transform grid_xform;
-	Transform edit_grid_xform;
+	Transform3D grid_xform;
+	Transform3D edit_grid_xform;
 	Vector3::Axis edit_axis;
 	int edit_floor[3];
 	Vector3 grid_ofs;
@@ -146,7 +146,7 @@ class GridMapEditor : public VBoxContainer {
 	PasteIndicator paste_indicator;
 
 	bool cursor_visible = false;
-	Transform cursor_transform;
+	Transform3D cursor_transform;
 
 	Vector3 cursor_origin;
 
diff --git a/modules/mobile_vr/mobile_vr_interface.cpp b/modules/mobile_vr/mobile_vr_interface.cpp
index 5140cfbbaf..a0731f90f3 100644
--- a/modules/mobile_vr/mobile_vr_interface.cpp
+++ b/modules/mobile_vr/mobile_vr_interface.cpp
@@ -361,10 +361,10 @@ Size2 MobileVRInterface::get_render_targetsize() {
 	return target_size;
 };
 
-Transform MobileVRInterface::get_transform_for_eye(XRInterface::Eyes p_eye, const Transform &p_cam_transform) {
+Transform3D MobileVRInterface::get_transform_for_eye(XRInterface::Eyes p_eye, const Transform3D &p_cam_transform) {
 	_THREAD_SAFE_METHOD_
 
-	Transform transform_for_eye;
+	Transform3D transform_for_eye;
 
 	XRServer *xr_server = XRServer::get_singleton();
 	ERR_FAIL_NULL_V(xr_server, transform_for_eye);
@@ -383,7 +383,7 @@ Transform MobileVRInterface::get_transform_for_eye(XRInterface::Eyes p_eye, cons
 		};
 
 		// just scale our origin point of our transform
-		Transform hmd_transform;
+		Transform3D hmd_transform;
 		hmd_transform.basis = orientation;
 		hmd_transform.origin = Vector3(0.0, eye_height * world_scale, 0.0);
 
diff --git a/modules/mobile_vr/mobile_vr_interface.h b/modules/mobile_vr/mobile_vr_interface.h
index d28c2196af..aad40ebb5b 100644
--- a/modules/mobile_vr/mobile_vr_interface.h
+++ b/modules/mobile_vr/mobile_vr_interface.h
@@ -139,7 +139,7 @@ public:
 
 	virtual Size2 get_render_targetsize() override;
 	virtual bool is_stereo() override;
-	virtual Transform get_transform_for_eye(XRInterface::Eyes p_eye, const Transform &p_cam_transform) override;
+	virtual Transform3D get_transform_for_eye(XRInterface::Eyes p_eye, const Transform3D &p_cam_transform) override;
 	virtual CameraMatrix get_projection_for_eye(XRInterface::Eyes p_eye, real_t p_aspect, real_t p_z_near, real_t p_z_far) override;
 	virtual void commit_for_eye(XRInterface::Eyes p_eye, RID p_render_target, const Rect2 &p_screen_rect) override;
 
diff --git a/modules/mono/csharp_script.cpp b/modules/mono/csharp_script.cpp
index b6a7a7579c..1f07f58ecc 100644
--- a/modules/mono/csharp_script.cpp
+++ b/modules/mono/csharp_script.cpp
@@ -499,7 +499,7 @@ static String variant_type_to_managed_name(const String &p_var_type_name) {
 		Variant::QUAT,
 		Variant::AABB,
 		Variant::BASIS,
-		Variant::TRANSFORM,
+		Variant::TRANSFORM3D,
 		Variant::COLOR,
 		Variant::STRING_NAME,
 		Variant::NODE_PATH,
diff --git a/modules/mono/editor/bindings_generator.cpp b/modules/mono/editor/bindings_generator.cpp
index b48e5df9eb..c2707e46d9 100644
--- a/modules/mono/editor/bindings_generator.cpp
+++ b/modules/mono/editor/bindings_generator.cpp
@@ -2520,8 +2520,8 @@ bool BindingsGenerator::_arg_default_value_is_assignable_to_type(const Variant &
 				   p_arg_type.name == name_cache.type_NodePath;
 		case Variant::NODE_PATH:
 			return p_arg_type.name == name_cache.type_NodePath;
-		case Variant::TRANSFORM:
 		case Variant::TRANSFORM2D:
+		case Variant::TRANSFORM3D:
 		case Variant::BASIS:
 		case Variant::QUAT:
 		case Variant::PLANE:
@@ -3123,13 +3123,13 @@ 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()) {
-				r_iarg.default_argument = "Transform.Identity";
+		case Variant::TRANSFORM3D: {
+			Transform3D transform = p_val.operator Transform3D();
+			if (transform == Transform3D()) {
+				r_iarg.default_argument = "Transform3D.Identity";
 			} else {
 				Basis basis = transform.basis;
-				r_iarg.default_argument = "new Transform(new Vector3" + basis.get_column(0).operator String() + ", new Vector3" + basis.get_column(1).operator String() + ", new Vector3" + basis.get_column(2).operator String() + ", new Vector3" + transform.origin.operator String() + ")";
+				r_iarg.default_argument = "new Transform3D(new Vector3" + basis.get_column(0).operator String() + ", new Vector3" + basis.get_column(1).operator String() + ", new Vector3" + basis.get_column(2).operator String() + ", new Vector3" + transform.origin.operator String() + ")";
 			}
 			r_iarg.def_param_mode = ArgumentInterface::NULLABLE_VAL;
 		} break;
@@ -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/Transform3D.cs
index ac47f6029f..9e5ff2b315 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform.cs
+++ b/modules/mono/glue/GodotSharp/GodotSharp/Core/Transform3D.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/glue/GodotSharp/GodotSharp/GodotSharp.csproj b/modules/mono/glue/GodotSharp/GodotSharp/GodotSharp.csproj
index 54aaaf1f92..c3dd13d84b 100644
--- a/modules/mono/glue/GodotSharp/GodotSharp/GodotSharp.csproj
+++ b/modules/mono/glue/GodotSharp/GodotSharp/GodotSharp.csproj
@@ -58,8 +58,8 @@
     <Compile Include="Core\SignalAwaiter.cs" />
     <Compile Include="Core\StringExtensions.cs" />
     <Compile Include="Core\StringName.cs" />
-    <Compile Include="Core\Transform.cs" />
     <Compile Include="Core\Transform2D.cs" />
+    <Compile Include="Core\Transform3D.cs" />
     <Compile Include="Core\UnhandledExceptionArgs.cs" />
     <Compile Include="Core\Vector2.cs" />
     <Compile Include="Core\Vector2i.cs" />
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_cache.h b/modules/mono/mono_gd/gd_mono_cache.h
index 51370da452..a332d492b9 100644
--- a/modules/mono/mono_gd/gd_mono_cache.h
+++ b/modules/mono/mono_gd/gd_mono_cache.h
@@ -81,7 +81,7 @@ struct CachedData {
 	GDMonoClass *class_Vector3i;
 	GDMonoClass *class_Basis;
 	GDMonoClass *class_Quat;
-	GDMonoClass *class_Transform;
+	GDMonoClass *class_Transform3D;
 	GDMonoClass *class_AABB;
 	GDMonoClass *class_Color;
 	GDMonoClass *class_Plane;
diff --git a/modules/mono/mono_gd/gd_mono_field.cpp b/modules/mono/mono_gd/gd_mono_field.cpp
index 1d4d52dfce..97e3fe1677 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_Transform3D from = MARSHALLED_OUT(Transform3D, p_value.operator ::Transform3D());
 				mono_field_set_value(p_object, mono_field, &from);
 				break;
 			}
@@ -348,8 +348,8 @@ void GDMonoField::set_value_from_variant(MonoObject *p_object, const Variant &p_
 					GDMonoMarshal::M_Basis from = MARSHALLED_OUT(Basis, p_value.operator ::Basis());
 					mono_field_set_value(p_object, mono_field, &from);
 				} break;
-				case Variant::TRANSFORM: {
-					GDMonoMarshal::M_Transform from = MARSHALLED_OUT(Transform, p_value.operator ::Transform());
+				case Variant::TRANSFORM3D: {
+					GDMonoMarshal::M_Transform3D 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..0623755263 100644
--- a/modules/mono/mono_gd/gd_mono_marshal.cpp
+++ b/modules/mono/mono_gd/gd_mono_marshal.cpp
@@ -108,8 +108,8 @@ Variant::Type managed_to_variant_type(const ManagedType &p_type, bool *r_nil_is_
 				return Variant::QUAT;
 			}
 
-			if (vtclass == CACHED_CLASS(Transform)) {
-				return Variant::TRANSFORM;
+			if (vtclass == CACHED_CLASS(Transform3D)) {
+				return Variant::TRANSFORM3D;
 			}
 
 			if (vtclass == CACHED_CLASS(AABB)) {
@@ -520,9 +520,9 @@ MonoObject *variant_to_mono_object(const Variant &p_var) {
 			GDMonoMarshal::M_Basis from = MARSHALLED_OUT(Basis, p_var.operator ::Basis());
 			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Basis), &from);
 		}
-		case Variant::TRANSFORM: {
-			GDMonoMarshal::M_Transform from = MARSHALLED_OUT(Transform, p_var.operator ::Transform());
-			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Transform), &from);
+		case Variant::TRANSFORM3D: {
+			GDMonoMarshal::M_Transform3D from = MARSHALLED_OUT(Transform3D, p_var.operator ::Transform3D());
+			return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Transform3D), &from);
 		}
 		case Variant::COLOR: {
 			GDMonoMarshal::M_Color from = MARSHALLED_OUT(Color, p_var.operator ::Color());
@@ -620,7 +620,7 @@ size_t variant_get_managed_unboxed_size(const ManagedType &p_type) {
 			RETURN_CHECK_FOR_STRUCT(Vector3i);
 			RETURN_CHECK_FOR_STRUCT(Basis);
 			RETURN_CHECK_FOR_STRUCT(Quat);
-			RETURN_CHECK_FOR_STRUCT(Transform);
+			RETURN_CHECK_FOR_STRUCT(Transform3D);
 			RETURN_CHECK_FOR_STRUCT(AABB);
 			RETURN_CHECK_FOR_STRUCT(Color);
 			RETURN_CHECK_FOR_STRUCT(Plane);
@@ -725,7 +725,7 @@ void *variant_to_managed_unboxed(const Variant &p_var, const ManagedType &p_type
 			RETURN_CHECK_FOR_STRUCT(Vector3i);
 			RETURN_CHECK_FOR_STRUCT(Basis);
 			RETURN_CHECK_FOR_STRUCT(Quat);
-			RETURN_CHECK_FOR_STRUCT(Transform);
+			RETURN_CHECK_FOR_STRUCT(Transform3D);
 			RETURN_CHECK_FOR_STRUCT(AABB);
 			RETURN_CHECK_FOR_STRUCT(Color);
 			RETURN_CHECK_FOR_STRUCT(Plane);
@@ -881,7 +881,7 @@ MonoObject *variant_to_mono_object(const Variant &p_var, const ManagedType &p_ty
 			RETURN_CHECK_FOR_STRUCT(Vector3i);
 			RETURN_CHECK_FOR_STRUCT(Basis);
 			RETURN_CHECK_FOR_STRUCT(Quat);
-			RETURN_CHECK_FOR_STRUCT(Transform);
+			RETURN_CHECK_FOR_STRUCT(Transform3D);
 			RETURN_CHECK_FOR_STRUCT(AABB);
 			RETURN_CHECK_FOR_STRUCT(Color);
 			RETURN_CHECK_FOR_STRUCT(Plane);
@@ -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)
diff --git a/modules/raycast/raycast_occlusion_cull.cpp b/modules/raycast/raycast_occlusion_cull.cpp
index 66558efa8c..88c0145ebc 100644
--- a/modules/raycast/raycast_occlusion_cull.cpp
+++ b/modules/raycast/raycast_occlusion_cull.cpp
@@ -64,7 +64,7 @@ void RaycastOcclusionCull::RaycastHZBuffer::resize(const Size2i &p_size) {
 	camera_ray_masks.resize(ray_packets_count * TILE_SIZE * TILE_SIZE);
 }
 
-void RaycastOcclusionCull::RaycastHZBuffer::update_camera_rays(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, ThreadWorkPool &p_thread_work_pool) {
+void RaycastOcclusionCull::RaycastHZBuffer::update_camera_rays(const Transform3D &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, ThreadWorkPool &p_thread_work_pool) {
 	CameraRayThreadData td;
 	td.camera_matrix = p_cam_projection;
 	td.camera_transform = p_cam_transform;
@@ -82,7 +82,7 @@ void RaycastOcclusionCull::RaycastHZBuffer::_camera_rays_threaded(uint32_t p_thr
 	_generate_camera_rays(p_data->camera_transform, p_data->camera_matrix, p_data->camera_orthogonal, from, to);
 }
 
-void RaycastOcclusionCull::RaycastHZBuffer::_generate_camera_rays(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, int p_from, int p_to) {
+void RaycastOcclusionCull::RaycastHZBuffer::_generate_camera_rays(const Transform3D &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, int p_from, int p_to) {
 	Size2i buffer_size = sizes[0];
 
 	CameraMatrix inv_camera_matrix = p_cam_projection.inverse();
@@ -227,7 +227,7 @@ void RaycastOcclusionCull::remove_scenario(RID p_scenario) {
 	scenario.removed = true;
 }
 
-void RaycastOcclusionCull::scenario_set_instance(RID p_scenario, RID p_instance, RID p_occluder, const Transform &p_xform, bool p_enabled) {
+void RaycastOcclusionCull::scenario_set_instance(RID p_scenario, RID p_instance, RID p_occluder, const Transform3D &p_xform, bool p_enabled) {
 	ERR_FAIL_COND(!scenarios.has(p_scenario));
 	Scenario &scenario = scenarios[p_scenario];
 
@@ -345,7 +345,7 @@ void RaycastOcclusionCull::Scenario::_transform_vertices_thread(uint32_t p_threa
 	_transform_vertices_range(p_data->read, p_data->write, p_data->xform, from, to);
 }
 
-void RaycastOcclusionCull::Scenario::_transform_vertices_range(const Vector3 *p_read, Vector3 *p_write, const Transform &p_xform, int p_from, int p_to) {
+void RaycastOcclusionCull::Scenario::_transform_vertices_range(const Vector3 *p_read, Vector3 *p_write, const Transform3D &p_xform, int p_from, int p_to) {
 	for (int i = p_from; i < p_to; i++) {
 		p_write[i] = p_xform.xform(p_read[i]);
 	}
@@ -491,7 +491,7 @@ void RaycastOcclusionCull::buffer_set_size(RID p_buffer, const Vector2i &p_size)
 	buffers[p_buffer].resize(p_size);
 }
 
-void RaycastOcclusionCull::buffer_update(RID p_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, ThreadWorkPool &p_thread_pool) {
+void RaycastOcclusionCull::buffer_update(RID p_buffer, const Transform3D &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, ThreadWorkPool &p_thread_pool) {
 	if (!buffers.has(p_buffer)) {
 		return;
 	}
diff --git a/modules/raycast/raycast_occlusion_cull.h b/modules/raycast/raycast_occlusion_cull.h
index acaceb9459..d9ca57cf24 100644
--- a/modules/raycast/raycast_occlusion_cull.h
+++ b/modules/raycast/raycast_occlusion_cull.h
@@ -52,14 +52,14 @@ public:
 
 		struct CameraRayThreadData {
 			CameraMatrix camera_matrix;
-			Transform camera_transform;
+			Transform3D camera_transform;
 			bool camera_orthogonal;
 			int thread_count;
 			Size2i buffer_size;
 		};
 
 		void _camera_rays_threaded(uint32_t p_thread, CameraRayThreadData *p_data);
-		void _generate_camera_rays(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, int p_from, int p_to);
+		void _generate_camera_rays(const Transform3D &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, int p_from, int p_to);
 
 	public:
 		LocalVector<RayPacket> camera_rays;
@@ -69,7 +69,7 @@ public:
 		virtual void clear() override;
 		virtual void resize(const Size2i &p_size) override;
 		void sort_rays();
-		void update_camera_rays(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, ThreadWorkPool &p_thread_work_pool);
+		void update_camera_rays(const Transform3D &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, ThreadWorkPool &p_thread_work_pool);
 	};
 
 private:
@@ -99,7 +99,7 @@ private:
 		RID occluder;
 		LocalVector<uint32_t> indices;
 		LocalVector<Vector3> xformed_vertices;
-		Transform xform;
+		Transform3D xform;
 		bool enabled = true;
 		bool removed = false;
 	};
@@ -113,7 +113,7 @@ private:
 		struct TransformThreadData {
 			uint32_t thread_count;
 			uint32_t vertex_count;
-			Transform xform;
+			Transform3D xform;
 			const Vector3 *read;
 			Vector3 *write;
 		};
@@ -134,7 +134,7 @@ private:
 		void _update_dirty_instance_thread(int p_idx, RID *p_instances);
 		void _update_dirty_instance(int p_idx, RID *p_instances, ThreadWorkPool *p_thread_pool);
 		void _transform_vertices_thread(uint32_t p_thread, TransformThreadData *p_data);
-		void _transform_vertices_range(const Vector3 *p_read, Vector3 *p_write, const Transform &p_xform, int p_from, int p_to);
+		void _transform_vertices_range(const Vector3 *p_read, Vector3 *p_write, const Transform3D &p_xform, int p_from, int p_to);
 		static void _commit_scene(void *p_ud);
 		bool update(ThreadWorkPool &p_thread_pool);
 
@@ -164,7 +164,7 @@ public:
 
 	virtual void add_scenario(RID p_scenario) override;
 	virtual void remove_scenario(RID p_scenario) override;
-	virtual void scenario_set_instance(RID p_scenario, RID p_instance, RID p_occluder, const Transform &p_xform, bool p_enabled) override;
+	virtual void scenario_set_instance(RID p_scenario, RID p_instance, RID p_occluder, const Transform3D &p_xform, bool p_enabled) override;
 	virtual void scenario_remove_instance(RID p_scenario, RID p_instance) override;
 
 	virtual void add_buffer(RID p_buffer) override;
@@ -172,7 +172,7 @@ public:
 	virtual HZBuffer *buffer_get_ptr(RID p_buffer) override;
 	virtual void buffer_set_scenario(RID p_buffer, RID p_scenario) override;
 	virtual void buffer_set_size(RID p_buffer, const Vector2i &p_size) override;
-	virtual void buffer_update(RID p_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, ThreadWorkPool &p_thread_pool) override;
+	virtual void buffer_update(RID p_buffer, const Transform3D &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, ThreadWorkPool &p_thread_pool) override;
 	virtual RID buffer_get_debug_texture(RID p_buffer) override;
 
 	virtual void set_build_quality(RS::ViewportOcclusionCullingBuildQuality p_quality) override;
diff --git a/modules/visual_script/visual_script_editor.cpp b/modules/visual_script/visual_script_editor.cpp
index 7432440603..779f366c86 100644
--- a/modules/visual_script/visual_script_editor.cpp
+++ b/modules/visual_script/visual_script_editor.cpp
@@ -390,7 +390,7 @@ static Color _color_from_type(Variant::Type p_type, bool dark_theme = true) {
 			case Variant::BASIS:
 				color = Color(0.89, 0.93, 0.41);
 				break;
-			case Variant::TRANSFORM:
+			case Variant::TRANSFORM3D:
 				color = Color(0.96, 0.66, 0.43);
 				break;
 
@@ -496,7 +496,7 @@ static Color _color_from_type(Variant::Type p_type, bool dark_theme = true) {
 			case Variant::BASIS:
 				color = Color(0.7, 0.73, 0.1);
 				break;
-			case Variant::TRANSFORM:
+			case Variant::TRANSFORM3D:
 				color = Color(0.96, 0.56, 0.28);
 				break;
 
diff --git a/modules/visual_script/visual_script_nodes.cpp b/modules/visual_script/visual_script_nodes.cpp
index fed6637acb..2dd18a492c 100644
--- a/modules/visual_script/visual_script_nodes.cpp
+++ b/modules/visual_script/visual_script_nodes.cpp
@@ -3921,7 +3921,7 @@ void register_visual_script_nodes() {
 	VisualScriptLanguage::singleton->add_register_func("functions/deconstruct/" + Variant::get_type_name(Variant::Type::QUAT), create_node_deconst_typed<Variant::Type::QUAT>);
 	VisualScriptLanguage::singleton->add_register_func("functions/deconstruct/" + Variant::get_type_name(Variant::Type::AABB), create_node_deconst_typed<Variant::Type::AABB>);
 	VisualScriptLanguage::singleton->add_register_func("functions/deconstruct/" + Variant::get_type_name(Variant::Type::BASIS), create_node_deconst_typed<Variant::Type::BASIS>);
-	VisualScriptLanguage::singleton->add_register_func("functions/deconstruct/" + Variant::get_type_name(Variant::Type::TRANSFORM), create_node_deconst_typed<Variant::Type::TRANSFORM>);
+	VisualScriptLanguage::singleton->add_register_func("functions/deconstruct/" + Variant::get_type_name(Variant::Type::TRANSFORM3D), create_node_deconst_typed<Variant::Type::TRANSFORM3D>);
 	VisualScriptLanguage::singleton->add_register_func("functions/compose_array", create_node_generic<VisualScriptComposeArray>);
 
 	for (int i = 1; i < Variant::VARIANT_MAX; i++) {
diff --git a/modules/webxr/webxr_interface_js.cpp b/modules/webxr/webxr_interface_js.cpp
index 06f3fe6284..a628cb0549 100644
--- a/modules/webxr/webxr_interface_js.cpp
+++ b/modules/webxr/webxr_interface_js.cpp
@@ -266,7 +266,7 @@ void WebXRInterfaceJS::uninitialize() {
 };
 
 Transform WebXRInterfaceJS::_js_matrix_to_transform(float *p_js_matrix) {
-	Transform transform;
+	Transform3D transform;
 
 	transform.basis.elements[0].x = p_js_matrix[0];
 	transform.basis.elements[1].x = p_js_matrix[1];
@@ -305,8 +305,8 @@ Size2 WebXRInterfaceJS::get_render_targetsize() {
 	return render_targetsize;
 };
 
-Transform WebXRInterfaceJS::get_transform_for_eye(XRInterface::Eyes p_eye, const Transform &p_cam_transform) {
-	Transform transform_for_eye;
+Transform WebXRInterfaceJS::get_transform_for_eye(XRInterface::Eyes p_eye, const Transform3D &p_cam_transform) {
+	Transform3D transform_for_eye;
 
 	XRServer *xr_server = XRServer::get_singleton();
 	ERR_FAIL_NULL_V(xr_server, transform_for_eye);
@@ -399,7 +399,7 @@ void WebXRInterfaceJS::_update_tracker(int p_controller_id) {
 
 		float *tracker_matrix = godot_webxr_get_controller_transform(p_controller_id);
 		if (tracker_matrix) {
-			Transform transform = _js_matrix_to_transform(tracker_matrix);
+			Transform3D transform = _js_matrix_to_transform(tracker_matrix);
 			tracker->set_position(transform.origin);
 			tracker->set_orientation(transform.basis);
 			free(tracker_matrix);
diff --git a/modules/webxr/webxr_interface_js.h b/modules/webxr/webxr_interface_js.h
index 7c841c1911..e9274a06e4 100644
--- a/modules/webxr/webxr_interface_js.h
+++ b/modules/webxr/webxr_interface_js.h
@@ -56,7 +56,7 @@ private:
 	bool controllers_state[2];
 	Size2 render_targetsize;
 
-	Transform _js_matrix_to_transform(float *p_js_matrix);
+	Transform3D _js_matrix_to_transform(float *p_js_matrix);
 	void _update_tracker(int p_controller_id);
 
 public:
@@ -84,7 +84,7 @@ public:
 
 	virtual Size2 get_render_targetsize() override;
 	virtual bool is_stereo() override;
-	virtual Transform get_transform_for_eye(XRInterface::Eyes p_eye, const Transform &p_cam_transform) override;
+	virtual Transform get_transform_for_eye(XRInterface::Eyes p_eye, const Transform3D &p_cam_transform) override;
 	virtual CameraMatrix get_projection_for_eye(XRInterface::Eyes p_eye, real_t p_aspect, real_t p_z_near, real_t p_z_far) override;
 	virtual unsigned int get_external_texture_for_eye(XRInterface::Eyes p_eye) override;
 	virtual void commit_for_eye(XRInterface::Eyes p_eye, RID p_render_target, const Rect2 &p_screen_rect) override;