diff --git a/core/math/basis.cpp b/core/math/basis.cpp
index 34ed1c2d855..8fac25d32ce 100644
--- a/core/math/basis.cpp
+++ b/core/math/basis.cpp
@@ -694,6 +694,10 @@ bool Basis::is_equal_approx(const Basis &p_basis) const {
 	return rows[0].is_equal_approx(p_basis.rows[0]) && rows[1].is_equal_approx(p_basis.rows[1]) && rows[2].is_equal_approx(p_basis.rows[2]);
 }
 
+bool Basis::is_semantic_equal(const Basis &p_basis) const {
+	return rows[0].is_semantic_equal(p_basis.rows[0]) && rows[1].is_semantic_equal(p_basis.rows[1]) && rows[2].is_semantic_equal(p_basis.rows[2]);
+}
+
 bool Basis::is_finite() const {
 	return rows[0].is_finite() && rows[1].is_finite() && rows[2].is_finite();
 }
diff --git a/core/math/basis.h b/core/math/basis.h
index 236d6661033..a210f87be8b 100644
--- a/core/math/basis.h
+++ b/core/math/basis.h
@@ -121,6 +121,7 @@ struct [[nodiscard]] Basis {
 	}
 
 	bool is_equal_approx(const Basis &p_basis) const;
+	bool is_semantic_equal(const Basis &p_basis) const;
 	bool is_finite() const;
 
 	bool operator==(const Basis &p_matrix) const;
diff --git a/core/math/plane.cpp b/core/math/plane.cpp
index 6b9bcea0813..015f441f68c 100644
--- a/core/math/plane.cpp
+++ b/core/math/plane.cpp
@@ -172,6 +172,10 @@ bool Plane::is_equal_approx(const Plane &p_plane) const {
 	return normal.is_equal_approx(p_plane.normal) && Math::is_equal_approx(d, p_plane.d);
 }
 
+bool Plane::is_semantic_equal(const Plane &p_plane) const {
+	return normal.is_semantic_equal(p_plane.normal) && Math::is_semantic_equal(d, p_plane.d);
+}
+
 bool Plane::is_finite() const {
 	return normal.is_finite() && Math::is_finite(d);
 }
diff --git a/core/math/plane.h b/core/math/plane.h
index 6529fea60ac..5aaa01ac109 100644
--- a/core/math/plane.h
+++ b/core/math/plane.h
@@ -73,6 +73,7 @@ struct [[nodiscard]] Plane {
 
 	Plane operator-() const { return Plane(-normal, -d); }
 	bool is_equal_approx(const Plane &p_plane) const;
+	bool is_semantic_equal(const Plane &p_plane) const;
 	bool is_equal_approx_any_side(const Plane &p_plane) const;
 	bool is_finite() const;
 
diff --git a/core/math/rect2.cpp b/core/math/rect2.cpp
index c55226a57ec..5a4c6591216 100644
--- a/core/math/rect2.cpp
+++ b/core/math/rect2.cpp
@@ -38,6 +38,10 @@ bool Rect2::is_equal_approx(const Rect2 &p_rect) const {
 	return position.is_equal_approx(p_rect.position) && size.is_equal_approx(p_rect.size);
 }
 
+bool Rect2::is_semantic_equal(const Rect2 &p_rect) const {
+	return position.is_semantic_equal(p_rect.position) && size.is_semantic_equal(p_rect.size);
+}
+
 bool Rect2::is_finite() const {
 	return position.is_finite() && size.is_finite();
 }
diff --git a/core/math/rect2.h b/core/math/rect2.h
index 817923c1348..d5999ed2b1a 100644
--- a/core/math/rect2.h
+++ b/core/math/rect2.h
@@ -203,6 +203,7 @@ struct [[nodiscard]] Rect2 {
 	}
 
 	bool is_equal_approx(const Rect2 &p_rect) const;
+	bool is_semantic_equal(const Rect2 &p_rect) const;
 	bool is_finite() const;
 
 	bool operator==(const Rect2 &p_rect) const { return position == p_rect.position && size == p_rect.size; }
diff --git a/core/math/transform_2d.cpp b/core/math/transform_2d.cpp
index f6525fe5caf..36c186cf369 100644
--- a/core/math/transform_2d.cpp
+++ b/core/math/transform_2d.cpp
@@ -180,6 +180,10 @@ bool Transform2D::is_equal_approx(const Transform2D &p_transform) const {
 	return columns[0].is_equal_approx(p_transform.columns[0]) && columns[1].is_equal_approx(p_transform.columns[1]) && columns[2].is_equal_approx(p_transform.columns[2]);
 }
 
+bool Transform2D::is_semantic_equal(const Transform2D &p_transform) const {
+	return columns[0].is_semantic_equal(p_transform.columns[0]) && columns[1].is_semantic_equal(p_transform.columns[1]) && columns[2].is_semantic_equal(p_transform.columns[2]);
+}
+
 bool Transform2D::is_finite() const {
 	return columns[0].is_finite() && columns[1].is_finite() && columns[2].is_finite();
 }
diff --git a/core/math/transform_2d.h b/core/math/transform_2d.h
index 1ee7d3d84f7..4637ea7c8e0 100644
--- a/core/math/transform_2d.h
+++ b/core/math/transform_2d.h
@@ -101,6 +101,7 @@ struct [[nodiscard]] Transform2D {
 	Transform2D orthonormalized() const;
 	bool is_conformal() const;
 	bool is_equal_approx(const Transform2D &p_transform) const;
+	bool is_semantic_equal(const Transform2D &p_transform) const;
 	bool is_finite() const;
 
 	Transform2D looking_at(const Vector2 &p_target) const;
diff --git a/core/math/transform_3d.cpp b/core/math/transform_3d.cpp
index 2c91a7604b0..dc47bd07f35 100644
--- a/core/math/transform_3d.cpp
+++ b/core/math/transform_3d.cpp
@@ -174,6 +174,10 @@ bool Transform3D::is_equal_approx(const Transform3D &p_transform) const {
 	return basis.is_equal_approx(p_transform.basis) && origin.is_equal_approx(p_transform.origin);
 }
 
+bool Transform3D::is_semantic_equal(const Transform3D &p_transform) const {
+	return basis.is_semantic_equal(p_transform.basis) && origin.is_semantic_equal(p_transform.origin);
+}
+
 bool Transform3D::is_finite() const {
 	return basis.is_finite() && origin.is_finite();
 }
diff --git a/core/math/transform_3d.h b/core/math/transform_3d.h
index b1de233445e..bdf1d04bfa6 100644
--- a/core/math/transform_3d.h
+++ b/core/math/transform_3d.h
@@ -75,6 +75,7 @@ struct [[nodiscard]] Transform3D {
 	void orthogonalize();
 	Transform3D orthogonalized() const;
 	bool is_equal_approx(const Transform3D &p_transform) const;
+	bool is_semantic_equal(const Transform3D &p_transform) const;
 	bool is_finite() const;
 
 	bool operator==(const Transform3D &p_transform) const;
diff --git a/core/variant/variant.cpp b/core/variant/variant.cpp
index e543c66d80d..ca103445243 100644
--- a/core/variant/variant.cpp
+++ b/core/variant/variant.cpp
@@ -3338,13 +3338,7 @@ bool Variant::hash_compare(const Variant &p_variant, int recursion_count, bool s
 			Transform2D *l = _data._transform2d;
 			Transform2D *r = p_variant._data._transform2d;
 
-			for (int i = 0; i < 3; i++) {
-				if (!hash_compare_vector2(l->columns[i], r->columns[i])) {
-					return false;
-				}
-			}
-
-			return true;
+			return l->is_semantic_equal(*r);
 		} break;
 
 		case VECTOR3: {
@@ -3376,17 +3370,14 @@ bool Variant::hash_compare(const Variant &p_variant, int recursion_count, bool s
 			const Plane *l = reinterpret_cast<const Plane *>(_data._mem);
 			const Plane *r = reinterpret_cast<const Plane *>(p_variant._data._mem);
 
-			return hash_compare_vector3(l->normal, r->normal) &&
-					hash_compare_scalar(l->d, r->d);
+			return l->is_semantic_equal(*r);
 		} break;
 
 		case AABB: {
 			const ::AABB *l = _data._aabb;
 			const ::AABB *r = p_variant._data._aabb;
 
-			return hash_compare_vector3(l->position, r->position) &&
-					hash_compare_vector3(l->size, r->size);
-
+			return l->is_semantic_equal(*r);
 		} break;
 
 		case QUATERNION: {
@@ -3400,26 +3391,14 @@ bool Variant::hash_compare(const Variant &p_variant, int recursion_count, bool s
 			const Basis *l = _data._basis;
 			const Basis *r = p_variant._data._basis;
 
-			for (int i = 0; i < 3; i++) {
-				if (!hash_compare_vector3(l->rows[i], r->rows[i])) {
-					return false;
-				}
-			}
-
-			return true;
+			return l->is_semantic_equal(*r);
 		} break;
 
 		case TRANSFORM3D: {
 			const Transform3D *l = _data._transform3d;
 			const Transform3D *r = p_variant._data._transform3d;
 
-			for (int i = 0; i < 3; i++) {
-				if (!hash_compare_vector3(l->basis.rows[i], r->basis.rows[i])) {
-					return false;
-				}
-			}
-
-			return hash_compare_vector3(l->origin, r->origin);
+			return l->is_semantic_equal(*r);
 		} break;
 		case PROJECTION: {
 			const Projection *l = _data._projection;