Tests for Rot2 renorm + change the used constructor to avoid a debug_…

…assertion.

crates/bevy_math/src/rotation2d.rs

@@ -233,10 +233,10 @@ impl Rot2 {
         let length_squared = self.length_squared();
         // Based on a taylor approximation of the inverse square root, see `[Dir3::fast_renormalize]` for more details.
         let length_recip_approx = 0.5 * (3.0 - length_squared);
-        Rot2::from_sin_cos(
-            self.sin * length_recip_approx,
-            self.cos * length_recip_approx,
-        )
+        Rot2 {
+            sin: self.sin * length_recip_approx,
+            cos: self.cos * length_recip_approx,
+        }
     }
 
     /// Returns `true` if the rotation is neither infinite nor NaN.
@@ -535,6 +535,40 @@ mod tests {
         assert!(normalized_rotation.is_normalized());
     }
 
+    #[test]
+    fn fast_renormalize() {
+        let rotation = Rot2 {
+            sin: 1.0,
+            cos: 0.5,
+        };
+        let normalized_rotation = rotation.normalize();
+
+        let mut unnormalized_rot = rotation;
+        let mut renormalized_rot = rotation;
+        let mut initially_normalized_rot = normalized_rotation;
+        let mut fully_normalized_rot = normalized_rotation;
+
+        // Compute a 64x (=2^6) multiple of the rotation.
+        for _ in 0..6 {
+            unnormalized_rot = unnormalized_rot * unnormalized_rot;
+            renormalized_rot = renormalized_rot * renormalized_rot;
+            initially_normalized_rot = initially_normalized_rot * initially_normalized_rot;
+            fully_normalized_rot = fully_normalized_rot * fully_normalized_rot;
+
+            renormalized_rot = renormalized_rot.fast_renormalize();
+            fully_normalized_rot = fully_normalized_rot.normalize();
+        }
+
+        assert!(!unnormalized_rot.is_normalized());
+
+        assert!(renormalized_rot.is_normalized());
+        assert!(fully_normalized_rot.is_normalized());
+
+        assert_relative_eq!(fully_normalized_rot, renormalized_rot, epsilon = 0.000001);
+        assert_relative_eq!(fully_normalized_rot, unnormalized_rot.normalize(), epsilon = 0.000001);
+        assert_relative_eq!(fully_normalized_rot, initially_normalized_rot.normalize(), epsilon = 0.000001);
+    }
+
     #[test]
     fn try_normalize() {
         // Valid