From 9881631b546c677d5f95fb571edc207fc6078bf9 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 00:50:41 +0200
Subject: [PATCH 01/21] Add `Angle` type and `Float` trait

---
 crates/bevy_gizmos/src/arcs.rs                |  17 +-
 crates/bevy_gizmos/src/circles.rs             |   4 +-
 crates/bevy_gltf/src/loader.rs                |   6 +-
 crates/bevy_input/src/touch.rs                |   4 +-
 crates/bevy_math/Cargo.toml                   |   1 +
 crates/bevy_math/src/angle.rs                 | 255 ++++++++++++++++++
 crates/bevy_math/src/float.rs                 | 161 +++++++++++
 crates/bevy_math/src/lib.rs                   |   7 +-
 crates/bevy_pbr/src/light.rs                  |  12 +-
 crates/bevy_pbr/src/render/light.rs           |   8 +-
 crates/bevy_reflect/src/impls/angle.rs        |   6 +
 crates/bevy_reflect/src/lib.rs                |   1 +
 .../src/components/transform.rs               |  49 ++--
 crates/bevy_winit/src/converters.rs           |   4 +-
 examples/2d/2d_gizmos.rs                      |   8 +-
 examples/2d/pixel_grid_snap.rs                |   2 +-
 examples/2d/rotation.rs                       |   9 +-
 examples/3d/3d_shapes.rs                      |   2 +-
 examples/3d/deferred_rendering.rs             |   8 +-
 examples/3d/generate_custom_mesh.rs           |   6 +-
 examples/3d/lighting.rs                       |  12 +-
 examples/3d/parallax_mapping.rs               |  10 +-
 examples/3d/parenting.rs                      |   2 +-
 examples/3d/render_to_texture.rs              |   8 +-
 examples/3d/skybox.rs                         |   2 +-
 examples/3d/spotlight.rs                      |   7 +-
 examples/ecs/hierarchy.rs                     |   4 +-
 examples/games/alien_cake_addict.rs           |   2 +-
 examples/games/contributors.rs                |   4 +-
 examples/shader/post_processing.rs            |   4 +-
 examples/stress_tests/many_cubes.rs           |   7 +-
 examples/stress_tests/many_foxes.rs           |   8 +-
 examples/stress_tests/many_gizmos.rs          |   2 +-
 examples/stress_tests/many_lights.rs          |   2 +-
 examples/stress_tests/many_sprites.rs         |   2 +-
 examples/stress_tests/transform_hierarchy.rs  |   7 +-
 examples/tools/gamepad_viewer.rs              |  13 +-
 examples/transforms/3d_rotation.rs            |   6 +-
 examples/window/low_power.rs                  |   4 +-
 39 files changed, 563 insertions(+), 113 deletions(-)
 create mode 100644 crates/bevy_math/src/angle.rs
 create mode 100644 crates/bevy_math/src/float.rs
 create mode 100644 crates/bevy_reflect/src/impls/angle.rs

diff --git a/crates/bevy_gizmos/src/arcs.rs b/crates/bevy_gizmos/src/arcs.rs
index c44ecd22b9d83..bd779c17ebc3b 100644
--- a/crates/bevy_gizmos/src/arcs.rs
+++ b/crates/bevy_gizmos/src/arcs.rs
@@ -5,7 +5,7 @@
 
 use crate::circles::DEFAULT_CIRCLE_SEGMENTS;
 use crate::prelude::Gizmos;
-use bevy_math::Vec2;
+use bevy_math::{Angle, Vec2};
 use bevy_render::color::Color;
 use std::f32::consts::TAU;
 
@@ -42,8 +42,8 @@ impl<'s> Gizmos<'s> {
     pub fn arc_2d(
         &mut self,
         position: Vec2,
-        direction_angle: f32,
-        arc_angle: f32,
+        direction_angle: Angle<f32>,
+        arc_angle: Angle<f32>,
         radius: f32,
         color: Color,
     ) -> Arc2dBuilder<'_, 's> {
@@ -63,8 +63,8 @@ impl<'s> Gizmos<'s> {
 pub struct Arc2dBuilder<'a, 's> {
     gizmos: &'a mut Gizmos<'s>,
     position: Vec2,
-    direction_angle: f32,
-    arc_angle: f32,
+    direction_angle: Angle<f32>,
+    arc_angle: Angle<f32>,
     radius: f32,
     color: Color,
     segments: Option<usize>,
@@ -84,7 +84,8 @@ impl Drop for Arc2dBuilder<'_, '_> {
             Some(segments) => segments,
             // Do a linear interpolation between 1 and `DEFAULT_CIRCLE_SEGMENTS`
             // using the arc angle as scalar.
-            None => ((self.arc_angle.abs() / TAU) * DEFAULT_CIRCLE_SEGMENTS as f32).ceil() as usize,
+            None => ((self.arc_angle.as_radians().abs() / TAU) * DEFAULT_CIRCLE_SEGMENTS as f32)
+                .ceil() as usize,
         };
 
         let positions = arc_inner(self.direction_angle, self.arc_angle, self.radius, segments)
@@ -94,8 +95,8 @@ impl Drop for Arc2dBuilder<'_, '_> {
 }
 
 fn arc_inner(
-    direction_angle: f32,
-    arc_angle: f32,
+    direction_angle: Angle<f32>,
+    arc_angle: Angle<f32>,
     radius: f32,
     segments: usize,
 ) -> impl Iterator<Item = Vec2> {
diff --git a/crates/bevy_gizmos/src/circles.rs b/crates/bevy_gizmos/src/circles.rs
index d24dec62e350e..57b43ca7bc9b8 100644
--- a/crates/bevy_gizmos/src/circles.rs
+++ b/crates/bevy_gizmos/src/circles.rs
@@ -4,7 +4,7 @@
 //! and assorted support items.
 
 use crate::prelude::Gizmos;
-use bevy_math::{Quat, Vec2, Vec3};
+use bevy_math::{Angle, Quat, Vec2, Vec3};
 use bevy_render::color::Color;
 use std::f32::consts::TAU;
 
@@ -12,7 +12,7 @@ pub(crate) const DEFAULT_CIRCLE_SEGMENTS: usize = 32;
 
 fn circle_inner(radius: f32, segments: usize) -> impl Iterator<Item = Vec2> {
     (0..segments + 1).map(move |i| {
-        let angle = i as f32 * TAU / segments as f32;
+        let angle = Angle::radians(i as f32 * TAU / segments as f32);
         Vec2::from(angle.sin_cos()) * radius
     })
 }
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 4d1d3e772f3a8..0ec8e134b05e2 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -7,7 +7,7 @@ use bevy_core_pipeline::prelude::Camera3dBundle;
 use bevy_ecs::{entity::Entity, world::World};
 use bevy_hierarchy::{BuildWorldChildren, WorldChildBuilder};
 use bevy_log::{error, warn};
-use bevy_math::{Mat4, Vec3};
+use bevy_math::{Angle, Mat4, Vec3};
 use bevy_pbr::{
     AlphaMode, DirectionalLight, DirectionalLightBundle, PbrBundle, PointLight, PointLightBundle,
     SpotLight, SpotLightBundle, StandardMaterial, MAX_JOINTS,
@@ -1101,8 +1101,8 @@ fn load_node(
                                 intensity: light.intensity() * std::f32::consts::PI * 4.0,
                                 range: light.range().unwrap_or(20.0),
                                 radius: light.range().unwrap_or(0.0),
-                                inner_angle: inner_cone_angle,
-                                outer_angle: outer_cone_angle,
+                                inner_angle: Angle::radians(inner_cone_angle),
+                                outer_angle: Angle::radians(outer_cone_angle),
                                 ..Default::default()
                             },
                             ..Default::default()
diff --git a/crates/bevy_input/src/touch.rs b/crates/bevy_input/src/touch.rs
index be8235fec0253..19b2a302e02ee 100644
--- a/crates/bevy_input/src/touch.rs
+++ b/crates/bevy_input/src/touch.rs
@@ -2,7 +2,7 @@
 
 use bevy_ecs::event::{Event, EventReader};
 use bevy_ecs::system::{ResMut, Resource};
-use bevy_math::Vec2;
+use bevy_math::{Angle, Vec2};
 use bevy_reflect::Reflect;
 use bevy_utils::HashMap;
 
@@ -83,7 +83,7 @@ pub enum ForceTouch {
         /// A value of 0 radians indicates that the stylus is parallel to the
         /// surface. The value of this property is Pi/2 when the stylus is
         /// perpendicular to the surface.
-        altitude_angle: Option<f64>,
+        altitude_angle: Option<Angle<f64>>,
     },
     /// If the platform reports the force as normalized, we have no way of
     /// knowing how much pressure 1.0 corresponds to – we know it's the maximum
diff --git a/crates/bevy_math/Cargo.toml b/crates/bevy_math/Cargo.toml
index 7ee418a42158e..c3128263e2b41 100644
--- a/crates/bevy_math/Cargo.toml
+++ b/crates/bevy_math/Cargo.toml
@@ -10,6 +10,7 @@ keywords = ["bevy"]
 
 [dependencies]
 glam = { version = "0.24.1", features = ["bytemuck"] }
+num-traits = { version = "0.2.17", default-features = false }
 serde = { version = "1", features = ["derive"], optional = true }
 
 [features]
diff --git a/crates/bevy_math/src/angle.rs b/crates/bevy_math/src/angle.rs
new file mode 100644
index 0000000000000..2bc8565c96ef3
--- /dev/null
+++ b/crates/bevy_math/src/angle.rs
@@ -0,0 +1,255 @@
+use std::{
+    fmt::Debug,
+    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign},
+};
+
+use super::{float::Float, Vec2};
+use glam::DVec2;
+
+/// An angle in radians.
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+pub struct Angle<T: Float>(T);
+
+impl<T: Float> Default for Angle<T> {
+    fn default() -> Self {
+        Self::ZERO
+    }
+}
+
+impl Angle<f32> {
+    /// Rotates the given vector by `self`.
+    #[inline]
+    pub fn rotate(&self, vec: Vec2) -> Vec2 {
+        Vec2::new(
+            vec.x * self.sin() + vec.y * self.cos(),
+            vec.x * self.cos() - vec.y * self.sin(),
+        )
+    }
+}
+
+impl Angle<f64> {
+    /// Rotates the given vector by `self`.
+    #[inline]
+    pub fn rotate(&self, vec: DVec2) -> DVec2 {
+        DVec2::new(
+            vec.x * self.sin() + vec.y * self.cos(),
+            vec.x * self.cos() - vec.y * self.sin(),
+        )
+    }
+}
+
+impl<T: Float> Angle<T> {
+    /// An angle of zero.
+    pub const ZERO: Self = Self(T::ZERO);
+    /// The angle 2π in radians.
+    pub const TAU: Self = Self(T::TAU);
+    /// The angle π (pi) in radians.
+    pub const PI: Self = Self(T::PI);
+    /// The angle π/2 in radians.
+    pub const FRAC_PI_2: Self = Self(T::FRAC_PI_2);
+    /// The angle π/3 in radians.
+    pub const FRAC_PI_3: Self = Self(T::FRAC_PI_3);
+    /// The angle π/4 in radians.
+    pub const FRAC_PI_4: Self = Self(T::FRAC_PI_4);
+    /// The angle π/6 in radians.
+    pub const FRAC_PI_6: Self = Self(T::FRAC_PI_6);
+    /// The angle π/8 in radians.
+    pub const FRAC_PI_8: Self = Self(T::FRAC_PI_8);
+
+    /// Returns the sine of the angle in radians.
+    #[inline]
+    pub fn sin(&self) -> T {
+        self.0.sin()
+    }
+
+    /// Returns the cosine of the angle in radians.
+    #[inline]
+    pub fn cos(&self) -> T {
+        self.0.cos()
+    }
+
+    /// Returns the tangent of the angle in radians.
+    #[inline]
+    pub fn tan(&self) -> T {
+        self.0.tan()
+    }
+
+    /// Returns the sine and cosine of the angle in radians.
+    #[inline]
+    pub fn sin_cos(&self) -> (T, T) {
+        self.0.sin_cos()
+    }
+
+    /// Creates an [`Angle`] from radians.
+    #[inline]
+    pub const fn radians(radians: T) -> Self {
+        Self(radians)
+    }
+
+    /// Creates an [`Angle`] from degrees.
+    #[inline]
+    pub fn degrees(degrees: T) -> Self {
+        Self(degrees.to_radians())
+    }
+
+    /// Returns the angle in radians.
+    #[inline]
+    pub fn as_radians(&self) -> T {
+        self.0
+    }
+
+    /// Returns the angle in degrees.
+    #[inline]
+    pub fn as_degrees(&self) -> T {
+        self.as_radians().to_degrees()
+    }
+
+    /// Returns the absolute angle.
+    #[inline]
+    pub fn abs(&self) -> Self {
+        Self(self.0.abs())
+    }
+
+    /// Returns the minimum of the two angles, ignoring NaN.
+    #[inline]
+    pub fn min(&self, other: Self) -> Self {
+        Angle::radians(self.0.min(other.0))
+    }
+}
+
+impl<T: Float> Add for Angle<T> {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl<T: Float> Sub for Angle<T> {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Self(self.0 - rhs.0)
+    }
+}
+
+impl<T: Float> Mul for Angle<T> {
+    type Output = Self;
+
+    fn mul(self, rhs: Self) -> Self::Output {
+        Self(self.0 * rhs.0)
+    }
+}
+
+impl<T: Float> Div for Angle<T> {
+    type Output = Self;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        Self(self.0 / rhs.0)
+    }
+}
+
+impl<T: Float> Mul<T> for Angle<T> {
+    type Output = Self;
+
+    fn mul(self, rhs: T) -> Self::Output {
+        Self(self.0 * rhs)
+    }
+}
+
+impl Mul<Angle<f32>> for f32 {
+    type Output = Angle<f32>;
+
+    fn mul(self, rhs: Angle<f32>) -> Self::Output {
+        Angle::radians(self * rhs.as_radians())
+    }
+}
+
+impl Mul<Angle<f64>> for f64 {
+    type Output = Angle<f64>;
+
+    fn mul(self, rhs: Angle<f64>) -> Self::Output {
+        Angle::radians(self * rhs.as_radians())
+    }
+}
+
+impl<T: Float> Div<T> for Angle<T> {
+    type Output = Self;
+
+    fn div(self, rhs: T) -> Self::Output {
+        Self::radians(self.as_radians() / rhs)
+    }
+}
+
+impl Div<Angle<f32>> for f32 {
+    type Output = Angle<f32>;
+
+    fn div(self, rhs: Angle<f32>) -> Self::Output {
+        Angle::radians(self / rhs.as_radians())
+    }
+}
+
+impl Div<Angle<f64>> for f64 {
+    type Output = Angle<f64>;
+
+    fn div(self, rhs: Angle<f64>) -> Self::Output {
+        Angle::radians(self / rhs.as_radians())
+    }
+}
+
+impl<T: Float> Neg for Angle<T> {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        Self(-self.0)
+    }
+}
+
+impl<T: Float> AddAssign<Angle<T>> for Angle<T> {
+    fn add_assign(&mut self, rhs: Angle<T>) {
+        self.0 += rhs.0;
+    }
+}
+
+impl<T: Float> SubAssign<Angle<T>> for Angle<T> {
+    fn sub_assign(&mut self, rhs: Angle<T>) {
+        self.0 -= rhs.0;
+    }
+}
+
+impl<T: Float> MulAssign<Angle<T>> for Angle<T> {
+    fn mul_assign(&mut self, rhs: Angle<T>) {
+        self.0 *= rhs.0;
+    }
+}
+
+impl<T: Float> DivAssign<Angle<T>> for Angle<T> {
+    fn div_assign(&mut self, rhs: Angle<T>) {
+        self.0 /= rhs.0;
+    }
+}
+
+impl<T: Float> AddAssign<T> for Angle<T> {
+    fn add_assign(&mut self, rhs: T) {
+        self.0 += rhs;
+    }
+}
+
+impl<T: Float> SubAssign<T> for Angle<T> {
+    fn sub_assign(&mut self, rhs: T) {
+        self.0 -= rhs;
+    }
+}
+
+impl<T: Float> MulAssign<T> for Angle<T> {
+    fn mul_assign(&mut self, rhs: T) {
+        self.0 *= rhs;
+    }
+}
+
+impl<T: Float> DivAssign<T> for Angle<T> {
+    fn div_assign(&mut self, rhs: T) {
+        self.0 /= rhs;
+    }
+}
diff --git a/crates/bevy_math/src/float.rs b/crates/bevy_math/src/float.rs
new file mode 100644
index 0000000000000..2b44dd12484a6
--- /dev/null
+++ b/crates/bevy_math/src/float.rs
@@ -0,0 +1,161 @@
+//! Contains a generic trait for floating-point numbers.
+
+use std::{
+    fmt::Debug,
+    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign},
+};
+
+/// A trait for generic floats.
+pub trait Float:
+    Sized
+    + Clone
+    + Copy
+    + Debug
+    + Default
+    + PartialEq<Self>
+    + PartialOrd<Self>
+    + Add<Self, Output = Self>
+    + Sub<Self, Output = Self>
+    + Mul<Self, Output = Self>
+    + Div<Self, Output = Self>
+    + AddAssign<Self>
+    + SubAssign<Self>
+    + MulAssign<Self>
+    + DivAssign<Self>
+    + Neg<Output = Self>
+{
+    /// A value of 0.
+    const ZERO: Self;
+    /// A value of 1.
+    const ONE: Self;
+    /// A value of -1.
+    const NEG_ONE: Self;
+    /// 2π
+    const TAU: Self;
+    /// π (pi)
+    const PI: Self;
+    /// π/2
+    const FRAC_PI_2: Self;
+    /// π/3
+    const FRAC_PI_3: Self;
+    /// π/4
+    const FRAC_PI_4: Self;
+    /// π/6
+    const FRAC_PI_6: Self;
+    /// π/8
+    const FRAC_PI_8: Self;
+
+    /// Computes the sine of a number (in radians).
+    fn sin(self) -> Self;
+    /// Computes the cosine of a number (in radians).
+    fn cos(self) -> Self;
+    /// Computes the tangent of a number (in radians).
+    fn tan(self) -> Self;
+    /// Simultaneously computes the sine and cosine of the number, `x`. Returns `(sin(x), cos(x))`.
+    fn sin_cos(self) -> (Self, Self);
+    /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`) in radians.
+    ///
+    /// - `x = 0`, `y = 0`: `0`
+    /// - `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
+    /// - `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
+    /// - `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
+    fn atan2(self, other: Self) -> Self;
+    /// Converts radians to degrees.
+    fn to_degrees(self) -> Self;
+    /// Converts degrees to radians.
+    fn to_radians(self) -> Self;
+    /// Computes the absolute value of `self`.
+    fn abs(self) -> Self;
+    /// Returns the minimum of the two numbers, ignoring NaN.
+    fn min(self, other: Self) -> Self;
+    /// Returns the maximum of the two numbers, ignoring NaN.
+    fn max(self, other: Self) -> Self;
+}
+
+impl Float for f32 {
+    const ZERO: Self = 0.0;
+    const ONE: Self = 1.0;
+    const NEG_ONE: Self = -1.0;
+    const TAU: Self = std::f32::consts::TAU;
+    const PI: Self = std::f32::consts::PI;
+    const FRAC_PI_2: Self = std::f32::consts::FRAC_PI_2;
+    const FRAC_PI_3: Self = std::f32::consts::FRAC_PI_3;
+    const FRAC_PI_4: Self = std::f32::consts::FRAC_PI_4;
+    const FRAC_PI_6: Self = std::f32::consts::FRAC_PI_6;
+    const FRAC_PI_8: Self = std::f32::consts::FRAC_PI_8;
+
+    fn sin(self) -> Self {
+        self.sin()
+    }
+    fn cos(self) -> Self {
+        self.cos()
+    }
+    fn tan(self) -> Self {
+        self.tan()
+    }
+    fn sin_cos(self) -> (Self, Self) {
+        self.sin_cos()
+    }
+    fn atan2(self, other: Self) -> Self {
+        self.atan2(other)
+    }
+    fn to_degrees(self) -> Self {
+        self.to_degrees()
+    }
+    fn to_radians(self) -> Self {
+        self.to_radians()
+    }
+    fn abs(self) -> Self {
+        self.abs()
+    }
+    fn min(self, other: Self) -> Self {
+        self.min(other)
+    }
+    fn max(self, other: Self) -> Self {
+        self.max(other)
+    }
+}
+
+impl Float for f64 {
+    const ZERO: Self = 0.0;
+    const ONE: Self = 1.0;
+    const NEG_ONE: Self = -1.0;
+    const TAU: Self = std::f64::consts::TAU;
+    const PI: Self = std::f64::consts::PI;
+    const FRAC_PI_2: Self = std::f64::consts::FRAC_PI_2;
+    const FRAC_PI_3: Self = std::f64::consts::FRAC_PI_3;
+    const FRAC_PI_4: Self = std::f64::consts::FRAC_PI_4;
+    const FRAC_PI_6: Self = std::f64::consts::FRAC_PI_6;
+    const FRAC_PI_8: Self = std::f64::consts::FRAC_PI_8;
+
+    fn sin(self) -> Self {
+        self.sin()
+    }
+    fn cos(self) -> Self {
+        self.cos()
+    }
+    fn tan(self) -> Self {
+        self.tan()
+    }
+    fn sin_cos(self) -> (Self, Self) {
+        self.sin_cos()
+    }
+    fn atan2(self, other: Self) -> Self {
+        self.atan2(other)
+    }
+    fn to_degrees(self) -> Self {
+        self.to_degrees()
+    }
+    fn to_radians(self) -> Self {
+        self.to_radians()
+    }
+    fn abs(self) -> Self {
+        self.abs()
+    }
+    fn min(self, other: Self) -> Self {
+        self.min(other)
+    }
+    fn max(self, other: Self) -> Self {
+        self.max(other)
+    }
+}
diff --git a/crates/bevy_math/src/lib.rs b/crates/bevy_math/src/lib.rs
index c6fb416d7eacf..751389b41715b 100644
--- a/crates/bevy_math/src/lib.rs
+++ b/crates/bevy_math/src/lib.rs
@@ -7,13 +7,16 @@
 #![warn(missing_docs)]
 
 mod affine3;
+mod angle;
 mod aspect_ratio;
 pub mod cubic_splines;
+pub mod float;
 pub mod primitives;
 mod ray;
 mod rects;
 
 pub use affine3::*;
+pub use angle::Angle;
 pub use aspect_ratio::AspectRatio;
 pub use ray::{Ray2d, Ray3d};
 pub use rects::*;
@@ -26,8 +29,8 @@ pub mod prelude {
             CubicBSpline, CubicBezier, CubicCardinalSpline, CubicGenerator, CubicHermite,
             CubicSegment,
         },
-        primitives, BVec2, BVec3, BVec4, EulerRot, IRect, IVec2, IVec3, IVec4, Mat2, Mat3, Mat4,
-        Quat, Ray2d, Ray3d, Rect, URect, UVec2, UVec3, UVec4, Vec2, Vec2Swizzles, Vec3,
+        primitives, Angle, BVec2, BVec3, BVec4, EulerRot, IRect, IVec2, IVec3, IVec4, Mat2, Mat3,
+        Mat4, Quat, Ray2d, Ray3d, Rect, URect, UVec2, UVec3, UVec4, Vec2, Vec2Swizzles, Vec3,
         Vec3Swizzles, Vec4, Vec4Swizzles,
     };
 }
diff --git a/crates/bevy_pbr/src/light.rs b/crates/bevy_pbr/src/light.rs
index c67d0cfe578cd..00a5a882dc994 100644
--- a/crates/bevy_pbr/src/light.rs
+++ b/crates/bevy_pbr/src/light.rs
@@ -2,7 +2,7 @@ use std::collections::HashSet;
 
 use bevy_ecs::prelude::*;
 use bevy_math::{
-    AspectRatio, Mat4, UVec2, UVec3, Vec2, Vec3, Vec3A, Vec3Swizzles, Vec4, Vec4Swizzles,
+    Angle, AspectRatio, Mat4, UVec2, UVec3, Vec2, Vec3, Vec3A, Vec3Swizzles, Vec4, Vec4Swizzles,
 };
 use bevy_reflect::prelude::*;
 use bevy_render::{
@@ -107,12 +107,12 @@ pub struct SpotLight {
     /// `outer_angle` should be < `PI / 2.0`.
     /// `PI / 2.0` defines a hemispherical spot light, but shadows become very blocky as the angle
     /// approaches this limit.
-    pub outer_angle: f32,
+    pub outer_angle: Angle<f32>,
     /// Angle defining the distance from the spot light direction to the inner limit
     /// of the light's cone of effect.
     /// Light is attenuated from `inner_angle` to `outer_angle` to give a smooth falloff.
     /// `inner_angle` should be <= `outer_angle`
-    pub inner_angle: f32,
+    pub inner_angle: Angle<f32>,
 }
 
 impl SpotLight {
@@ -131,8 +131,8 @@ impl Default for SpotLight {
             shadows_enabled: false,
             shadow_depth_bias: Self::DEFAULT_SHADOW_DEPTH_BIAS,
             shadow_normal_bias: Self::DEFAULT_SHADOW_NORMAL_BIAS,
-            inner_angle: 0.0,
-            outer_angle: std::f32::consts::FRAC_PI_4,
+            inner_angle: Angle::ZERO,
+            outer_angle: Angle::FRAC_PI_4,
         }
     }
 }
@@ -1155,7 +1155,7 @@ pub(crate) struct PointLightAssignmentData {
     transform: GlobalTransform,
     range: f32,
     shadows_enabled: bool,
-    spot_light_angle: Option<f32>,
+    spot_light_angle: Option<Angle<f32>>,
     render_layers: RenderLayers,
 }
 
diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
index 9b9b635ab0f83..9d948b7e53f15 100644
--- a/crates/bevy_pbr/src/render/light.rs
+++ b/crates/bevy_pbr/src/render/light.rs
@@ -1,6 +1,6 @@
 use bevy_core_pipeline::core_3d::{Transparent3d, CORE_3D_DEPTH_FORMAT};
 use bevy_ecs::prelude::*;
-use bevy_math::{Mat4, UVec3, UVec4, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles};
+use bevy_math::{Angle, Mat4, UVec3, UVec4, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles};
 use bevy_render::{
     camera::Camera,
     color::Color,
@@ -35,7 +35,7 @@ pub struct ExtractedPointLight {
     shadows_enabled: bool,
     shadow_depth_bias: f32,
     shadow_normal_bias: f32,
-    spot_light_angles: Option<(f32, f32)>,
+    spot_light_angles: Option<(Angle<f32>, Angle<f32>)>,
 }
 
 #[derive(Component, Debug)]
@@ -635,9 +635,9 @@ pub(crate) fn spot_light_view_matrix(transform: &GlobalTransform) -> Mat4 {
     )
 }
 
-pub(crate) fn spot_light_projection_matrix(angle: f32) -> Mat4 {
+pub(crate) fn spot_light_projection_matrix(angle: Angle<f32>) -> Mat4 {
     // spot light projection FOV is 2x the angle from spot light center to outer edge
-    Mat4::perspective_infinite_reverse_rh(angle * 2.0, 1.0, POINT_LIGHT_NEAR_Z)
+    Mat4::perspective_infinite_reverse_rh(angle.as_radians() * 2.0, 1.0, POINT_LIGHT_NEAR_Z)
 }
 
 #[allow(clippy::too_many_arguments)]
diff --git a/crates/bevy_reflect/src/impls/angle.rs b/crates/bevy_reflect/src/impls/angle.rs
new file mode 100644
index 0000000000000..a5ec8d63765ca
--- /dev/null
+++ b/crates/bevy_reflect/src/impls/angle.rs
@@ -0,0 +1,6 @@
+use crate as bevy_reflect;
+use crate::prelude::ReflectDefault;
+use bevy_math::float::Float;
+use bevy_reflect_derive::impl_reflect_value;
+
+impl_reflect_value!(::bevy_math::Angle<T: Float + std::marker::Sync + std::marker::Send>(Debug, Default));
diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
index 3ed140c6f207b..d0900a59b7510 100644
--- a/crates/bevy_reflect/src/lib.rs
+++ b/crates/bevy_reflect/src/lib.rs
@@ -490,6 +490,7 @@ mod impls {
     #[cfg(feature = "smol_str")]
     mod smol_str;
 
+    mod angle;
     mod std;
     mod uuid;
 }
diff --git a/crates/bevy_transform/src/components/transform.rs b/crates/bevy_transform/src/components/transform.rs
index 316ee97719d7e..43a29caadc920 100644
--- a/crates/bevy_transform/src/components/transform.rs
+++ b/crates/bevy_transform/src/components/transform.rs
@@ -1,5 +1,6 @@
 use super::GlobalTransform;
 use bevy_ecs::{component::Component, reflect::ReflectComponent};
+use bevy_math::Angle;
 use bevy_math::{Affine3A, Mat3, Mat4, Quat, Vec3};
 use bevy_reflect::prelude::*;
 use bevy_reflect::Reflect;
@@ -251,36 +252,36 @@ impl Transform {
         self.rotation = rotation * self.rotation;
     }
 
-    /// Rotates this [`Transform`] around the given `axis` by `angle` (in radians).
+    /// Rotates this [`Transform`] around the given `axis` by `angle` in the counterclockwise direction.
     ///
     /// If this [`Transform`] has a parent, the `axis` is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_axis(&mut self, axis: Vec3, angle: f32) {
-        self.rotate(Quat::from_axis_angle(axis, angle));
+    pub fn rotate_axis(&mut self, axis: Vec3, angle: Angle<f32>) {
+        self.rotate(Quat::from_axis_angle(axis, angle.as_radians()));
     }
 
-    /// Rotates this [`Transform`] around the `X` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around the `X` axis by `angle` in the counterclockwise direction.
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_x(&mut self, angle: f32) {
-        self.rotate(Quat::from_rotation_x(angle));
+    pub fn rotate_x(&mut self, angle: Angle<f32>) {
+        self.rotate(Quat::from_rotation_x(angle.as_radians()));
     }
 
-    /// Rotates this [`Transform`] around the `Y` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around the `Y` axis by `angle` in the counterclockwise direction.
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_y(&mut self, angle: f32) {
-        self.rotate(Quat::from_rotation_y(angle));
+    pub fn rotate_y(&mut self, angle: Angle<f32>) {
+        self.rotate(Quat::from_rotation_y(angle.as_radians()));
     }
 
-    /// Rotates this [`Transform`] around the `Z` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around the `Z` axis by `angle` in the counterclockwise direction.
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_z(&mut self, angle: f32) {
-        self.rotate(Quat::from_rotation_z(angle));
+    pub fn rotate_z(&mut self, angle: Angle<f32>) {
+        self.rotate(Quat::from_rotation_z(angle.as_radians()));
     }
 
     /// Rotates this [`Transform`] by the given `rotation`.
@@ -291,28 +292,28 @@ impl Transform {
         self.rotation *= rotation;
     }
 
-    /// Rotates this [`Transform`] around its local `axis` by `angle` (in radians).
+    /// Rotates this [`Transform`] around its local `axis` by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_axis(&mut self, axis: Vec3, angle: f32) {
-        self.rotate_local(Quat::from_axis_angle(axis, angle));
+    pub fn rotate_local_axis(&mut self, axis: Vec3, angle: Angle<f32>) {
+        self.rotate_local(Quat::from_axis_angle(axis, angle.as_radians()));
     }
 
-    /// Rotates this [`Transform`] around its local `X` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around its local `X` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_x(&mut self, angle: f32) {
-        self.rotate_local(Quat::from_rotation_x(angle));
+    pub fn rotate_local_x(&mut self, angle: Angle<f32>) {
+        self.rotate_local(Quat::from_rotation_x(angle.as_radians()));
     }
 
-    /// Rotates this [`Transform`] around its local `Y` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around its local `Y` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_y(&mut self, angle: f32) {
-        self.rotate_local(Quat::from_rotation_y(angle));
+    pub fn rotate_local_y(&mut self, angle: Angle<f32>) {
+        self.rotate_local(Quat::from_rotation_y(angle.as_radians()));
     }
 
-    /// Rotates this [`Transform`] around its local `Z` axis by `angle` (in radians).
+    /// Rotates this [`Transform`] around its local `Z` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_z(&mut self, angle: f32) {
-        self.rotate_local(Quat::from_rotation_z(angle));
+    pub fn rotate_local_z(&mut self, angle: Angle<f32>) {
+        self.rotate_local(Quat::from_rotation_z(angle.as_radians()));
     }
 
     /// Translates this [`Transform`] around a `point` in space.
diff --git a/crates/bevy_winit/src/converters.rs b/crates/bevy_winit/src/converters.rs
index 9817d5a4e98ae..1daef6d1334e8 100644
--- a/crates/bevy_winit/src/converters.rs
+++ b/crates/bevy_winit/src/converters.rs
@@ -5,7 +5,7 @@ use bevy_input::{
     touch::{ForceTouch, TouchInput, TouchPhase},
     ButtonState,
 };
-use bevy_math::Vec2;
+use bevy_math::{Angle, Vec2};
 use bevy_window::{CursorIcon, EnabledButtons, WindowLevel, WindowTheme};
 
 pub fn convert_keyboard_input(
@@ -57,7 +57,7 @@ pub fn convert_touch_input(
             } => ForceTouch::Calibrated {
                 force,
                 max_possible_force,
-                altitude_angle,
+                altitude_angle: altitude_angle.map(Angle::radians),
             },
             winit::event::Force::Normalized(x) => ForceTouch::Normalized(x),
         }),
diff --git a/examples/2d/2d_gizmos.rs b/examples/2d/2d_gizmos.rs
index d3dcd7c960f6a..95a63b087cc6b 100644
--- a/examples/2d/2d_gizmos.rs
+++ b/examples/2d/2d_gizmos.rs
@@ -52,7 +52,13 @@ fn system(mut gizmos: Gizmos, time: Res<Time>) {
 
     // Arcs default amount of segments is linearly interpolated between
     // 1 and 32, using the arc length as scalar.
-    gizmos.arc_2d(Vec2::ZERO, sin / 10., PI / 2., 350., Color::ORANGE_RED);
+    gizmos.arc_2d(
+        Vec2::ZERO,
+        Angle::radians(sin / 10.),
+        Angle::radians(PI / 2.),
+        350.,
+        Color::ORANGE_RED,
+    );
 
     gizmos.arrow_2d(
         Vec2::ZERO,
diff --git a/examples/2d/pixel_grid_snap.rs b/examples/2d/pixel_grid_snap.rs
index 15e573299380a..c8df698471c5c 100644
--- a/examples/2d/pixel_grid_snap.rs
+++ b/examples/2d/pixel_grid_snap.rs
@@ -156,7 +156,7 @@ fn setup_camera(mut commands: Commands, mut images: ResMut<Assets<Image>>) {
 fn rotate(time: Res<Time>, mut transforms: Query<&mut Transform, With<Rotate>>) {
     for mut transform in &mut transforms {
         let dt = time.delta_seconds();
-        transform.rotate_z(dt);
+        transform.rotate_z(Angle::radians(dt));
     }
 }
 
diff --git a/examples/2d/rotation.rs b/examples/2d/rotation.rs
index 75e80548c7c75..dde6149c86699 100644
--- a/examples/2d/rotation.rs
+++ b/examples/2d/rotation.rs
@@ -138,7 +138,9 @@ fn player_movement_system(
     }
 
     // update the ship rotation around the Z axis (perpendicular to the 2D plane of the screen)
-    transform.rotate_z(rotation_factor * ship.rotation_speed * time.delta_seconds());
+    transform.rotate_z(Angle::radians(
+        rotation_factor * ship.rotation_speed * time.delta_seconds(),
+    ));
 
     // get the ship's forward vector by applying the current rotation to the ships initial facing
     // vector
@@ -242,11 +244,12 @@ fn rotate_to_player_system(
 
         // limit rotation so we don't overshoot the target. We need to convert our dot product to
         // an angle here so we can get an angle of rotation to clamp against.
-        let max_angle = forward_dot_player.clamp(-1.0, 1.0).acos(); // clamp acos for safety
+        let max_angle = Angle::radians(forward_dot_player.clamp(-1.0, 1.0).acos());
 
         // calculate angle of rotation with limit
         let rotation_angle =
-            rotation_sign * (config.rotation_speed * time.delta_seconds()).min(max_angle);
+            Angle::radians(rotation_sign * (config.rotation_speed * time.delta_seconds()))
+                .min(max_angle);
 
         // rotate the enemy to face the player
         enemy_transform.rotate_z(rotation_angle);
diff --git a/examples/3d/3d_shapes.rs b/examples/3d/3d_shapes.rs
index 999d11a74c878..60db9e41febef 100644
--- a/examples/3d/3d_shapes.rs
+++ b/examples/3d/3d_shapes.rs
@@ -88,7 +88,7 @@ fn setup(
 
 fn rotate(mut query: Query<&mut Transform, With<Shape>>, time: Res<Time>) {
     for mut transform in &mut query {
-        transform.rotate_y(time.delta_seconds() / 2.);
+        transform.rotate_y(Angle::radians(time.delta_seconds() / 2.));
     }
 }
 
diff --git a/examples/3d/deferred_rendering.rs b/examples/3d/deferred_rendering.rs
index 6b5dbbe466715..03c7c3261ff68 100644
--- a/examples/3d/deferred_rendering.rs
+++ b/examples/3d/deferred_rendering.rs
@@ -240,7 +240,7 @@ fn animate_light_direction(
         return;
     }
     for mut transform in &mut query {
-        transform.rotate_y(time.delta_seconds() * PI / 5.0);
+        transform.rotate_y(Angle::radians(time.delta_seconds() * PI / 5.0));
     }
 }
 
@@ -282,7 +282,9 @@ fn setup_parallax(
             transform: Transform::from_xyz(0.4, 0.2, -0.8),
             ..default()
         },
-        Spin { speed: 0.3 },
+        Spin {
+            speed: Angle::radians(0.3),
+        },
     ));
 }
 
@@ -309,7 +311,7 @@ fn update_normal(
 
 #[derive(Component)]
 struct Spin {
-    speed: f32,
+    speed: Angle<f32>,
 }
 
 fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>, pause: Res<Pause>) {
diff --git a/examples/3d/generate_custom_mesh.rs b/examples/3d/generate_custom_mesh.rs
index aada1df1b7275..5d5ae714a5bab 100644
--- a/examples/3d/generate_custom_mesh.rs
+++ b/examples/3d/generate_custom_mesh.rs
@@ -98,17 +98,17 @@ fn input_handler(
     }
     if keyboard_input.pressed(KeyCode::KeyX) {
         for mut transform in &mut query {
-            transform.rotate_x(time.delta_seconds() / 1.2);
+            transform.rotate_x(Angle::radians(time.delta_seconds() / 1.2));
         }
     }
     if keyboard_input.pressed(KeyCode::KeyY) {
         for mut transform in &mut query {
-            transform.rotate_y(time.delta_seconds() / 1.2);
+            transform.rotate_y(Angle::radians(time.delta_seconds() / 1.2));
         }
     }
     if keyboard_input.pressed(KeyCode::KeyZ) {
         for mut transform in &mut query {
-            transform.rotate_z(time.delta_seconds() / 1.2);
+            transform.rotate_z(Angle::radians(time.delta_seconds() / 1.2));
         }
     }
     if keyboard_input.pressed(KeyCode::KeyR) {
diff --git a/examples/3d/lighting.rs b/examples/3d/lighting.rs
index e82e50145a5d3..a6e6cc4d6a594 100644
--- a/examples/3d/lighting.rs
+++ b/examples/3d/lighting.rs
@@ -36,7 +36,7 @@ fn setup(
 
     // left wall
     let mut transform = Transform::from_xyz(2.5, 2.5, 0.0);
-    transform.rotate_z(PI / 2.);
+    transform.rotate_z(Angle::FRAC_PI_2);
     commands.spawn(PbrBundle {
         mesh: meshes.add(Mesh::from(shape::Box::new(5.0, 0.15, 5.0))),
         transform,
@@ -49,7 +49,7 @@ fn setup(
     });
     // back (right) wall
     let mut transform = Transform::from_xyz(0.0, 2.5, -2.5);
-    transform.rotate_x(PI / 2.);
+    transform.rotate_x(Angle::FRAC_PI_2);
     commands.spawn(PbrBundle {
         mesh: meshes.add(Mesh::from(shape::Box::new(5.0, 0.15, 5.0))),
         transform,
@@ -63,7 +63,7 @@ fn setup(
 
     // Bevy logo to demonstrate alpha mask shadows
     let mut transform = Transform::from_xyz(-2.2, 0.5, 1.0);
-    transform.rotate_y(PI / 8.);
+    transform.rotate_y(Angle::FRAC_PI_8);
     commands.spawn((
         PbrBundle {
             mesh: meshes.add(Mesh::from(shape::Quad::new(Vec2::new(2.0, 0.5)))),
@@ -153,8 +153,8 @@ fn setup(
                 intensity: 1600.0, // lumens - roughly a 100W non-halogen incandescent bulb
                 color: Color::GREEN,
                 shadows_enabled: true,
-                inner_angle: 0.6,
-                outer_angle: 0.8,
+                inner_angle: Angle::radians(0.6),
+                outer_angle: Angle::radians(0.8),
                 ..default()
             },
             ..default()
@@ -256,7 +256,7 @@ fn animate_light_direction(
     mut query: Query<&mut Transform, With<DirectionalLight>>,
 ) {
     for mut transform in &mut query {
-        transform.rotate_y(time.delta_seconds() * 0.5);
+        transform.rotate_y(Angle::radians(time.delta_seconds() * 0.5));
     }
 }
 
diff --git a/examples/3d/parallax_mapping.rs b/examples/3d/parallax_mapping.rs
index dfdca7d2e222c..fb77676a9a6ef 100644
--- a/examples/3d/parallax_mapping.rs
+++ b/examples/3d/parallax_mapping.rs
@@ -27,7 +27,7 @@ fn main() {
 
 #[derive(Component)]
 struct Spin {
-    speed: f32,
+    speed: Angle<f32>,
 }
 
 /// The camera, used to move camera on click.
@@ -291,7 +291,9 @@ fn setup(
             material: parallax_material.clone_weak(),
             ..default()
         },
-        Spin { speed: 0.3 },
+        Spin {
+            speed: Angle::radians(0.3),
+        },
     ));
 
     let background_cube = meshes.add(
@@ -308,7 +310,9 @@ fn setup(
                 material: parallax_material.clone(),
                 ..default()
             },
-            Spin { speed: -0.1 },
+            Spin {
+                speed: Angle::radians(-0.1),
+            },
         )
     };
     commands.spawn(background_cube_bundle(Vec3::new(45., 0., 0.)));
diff --git a/examples/3d/parenting.rs b/examples/3d/parenting.rs
index 827d8ffbec782..4ec6c6187c256 100644
--- a/examples/3d/parenting.rs
+++ b/examples/3d/parenting.rs
@@ -18,7 +18,7 @@ struct Rotator;
 /// rotates the parent, which will result in the child also rotating
 fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotator>>) {
     for mut transform in &mut query {
-        transform.rotate_x(3.0 * time.delta_seconds());
+        transform.rotate_x(Angle::radians(3.0 * time.delta_seconds()));
     }
 }
 
diff --git a/examples/3d/render_to_texture.rs b/examples/3d/render_to_texture.rs
index a319e7d6e4e03..788e1b2e73373 100644
--- a/examples/3d/render_to_texture.rs
+++ b/examples/3d/render_to_texture.rs
@@ -150,15 +150,15 @@ fn setup(
 /// Rotates the inner cube (first pass)
 fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<FirstPassCube>>) {
     for mut transform in &mut query {
-        transform.rotate_x(1.5 * time.delta_seconds());
-        transform.rotate_z(1.3 * time.delta_seconds());
+        transform.rotate_x(Angle::radians(1.5 * time.delta_seconds()));
+        transform.rotate_z(Angle::radians(1.3 * time.delta_seconds()));
     }
 }
 
 /// Rotates the outer cube (main pass)
 fn cube_rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<MainPassCube>>) {
     for mut transform in &mut query {
-        transform.rotate_x(1.0 * time.delta_seconds());
-        transform.rotate_y(0.7 * time.delta_seconds());
+        transform.rotate_x(Angle::radians(1.0 * time.delta_seconds()));
+        transform.rotate_y(Angle::radians(0.7 * time.delta_seconds()));
     }
 }
diff --git a/examples/3d/skybox.rs b/examples/3d/skybox.rs
index faca13bf1f4f6..a40aef0da9b4e 100644
--- a/examples/3d/skybox.rs
+++ b/examples/3d/skybox.rs
@@ -166,7 +166,7 @@ fn animate_light_direction(
     mut query: Query<&mut Transform, With<DirectionalLight>>,
 ) {
     for mut transform in &mut query {
-        transform.rotate_y(time.delta_seconds() * 0.5);
+        transform.rotate_y(Angle::radians(time.delta_seconds() * 0.5));
     }
 }
 
diff --git a/examples/3d/spotlight.rs b/examples/3d/spotlight.rs
index 9331f01635d61..bcde184792a85 100644
--- a/examples/3d/spotlight.rs
+++ b/examples/3d/spotlight.rs
@@ -90,8 +90,8 @@ fn setup(
                         intensity: 200.0, // lumens
                         color: Color::WHITE,
                         shadows_enabled: true,
-                        inner_angle: PI / 4.0 * 0.85,
-                        outer_angle: PI / 4.0,
+                        inner_angle: Angle::FRAC_PI_4 * 0.85,
+                        outer_angle: Angle::FRAC_PI_4,
                         ..default()
                     },
                     ..default()
@@ -134,7 +134,8 @@ fn light_sway(time: Res<Time>, mut query: Query<(&mut Transform, &mut SpotLight)
             (time.elapsed_seconds() * 3.0).sin() * 0.5,
             0.0,
         );
-        let angle = ((time.elapsed_seconds() * 1.2).sin() + 1.0) * (FRAC_PI_4 - 0.1);
+        let angle =
+            Angle::radians(((time.elapsed_seconds() * 1.2).sin() + 1.0) * (FRAC_PI_4 - 0.1));
         angles.inner_angle = angle * 0.8;
         angles.outer_angle = angle;
     }
diff --git a/examples/ecs/hierarchy.rs b/examples/ecs/hierarchy.rs
index f4cb13141c7ab..e0ea34a8544a7 100644
--- a/examples/ecs/hierarchy.rs
+++ b/examples/ecs/hierarchy.rs
@@ -66,14 +66,14 @@ fn rotate(
 ) {
     for (parent, children) in &mut parents_query {
         if let Ok(mut transform) = transform_query.get_mut(parent) {
-            transform.rotate_z(-PI / 2. * time.delta_seconds());
+            transform.rotate_z(Angle::radians(-PI / 2. * time.delta_seconds()));
         }
 
         // To iterate through the entities children, just treat the Children component as a Vec
         // Alternatively, you could query entities that have a Parent component
         for child in children {
             if let Ok(mut transform) = transform_query.get_mut(*child) {
-                transform.rotate_z(PI * time.delta_seconds());
+                transform.rotate_z(Angle::radians(PI * time.delta_seconds()));
             }
         }
 
diff --git a/examples/games/alien_cake_addict.rs b/examples/games/alien_cake_addict.rs
index a7f9b46805a70..d803a8c387b1c 100644
--- a/examples/games/alien_cake_addict.rs
+++ b/examples/games/alien_cake_addict.rs
@@ -360,7 +360,7 @@ fn spawn_bonus(
 fn rotate_bonus(game: Res<Game>, time: Res<Time>, mut transforms: Query<&mut Transform>) {
     if let Some(entity) = game.bonus.entity {
         if let Ok(mut cake_transform) = transforms.get_mut(entity) {
-            cake_transform.rotate_y(time.delta_seconds());
+            cake_transform.rotate_y(Angle::radians(time.delta_seconds()));
             cake_transform.scale =
                 Vec3::splat(1.0 + (game.score as f32 / 10.0 * time.elapsed_seconds().sin()).abs());
         }
diff --git a/examples/games/contributors.rs b/examples/games/contributors.rs
index 4fd8309a2f8f5..30ff45796fd19 100644
--- a/examples/games/contributors.rs
+++ b/examples/games/contributors.rs
@@ -64,7 +64,7 @@ struct Contributor {
 #[derive(Component)]
 struct Velocity {
     translation: Vec3,
-    rotation: f32,
+    rotation: Angle<f32>,
 }
 
 const GRAVITY: f32 = 9.821 * 100.0;
@@ -115,7 +115,7 @@ fn setup_contributor_selection(mut commands: Commands, asset_server: Res<AssetSe
                 Contributor { name, hue },
                 Velocity {
                     translation: velocity,
-                    rotation: -dir * 5.0,
+                    rotation: Angle::radians(-dir * 5.0),
                 },
                 SpriteBundle {
                     sprite: Sprite {
diff --git a/examples/shader/post_processing.rs b/examples/shader/post_processing.rs
index ad684675d806b..820f3a95a22af 100644
--- a/examples/shader/post_processing.rs
+++ b/examples/shader/post_processing.rs
@@ -342,8 +342,8 @@ struct Rotates;
 /// Rotates any entity around the x and y axis
 fn rotate(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
     for mut transform in &mut query {
-        transform.rotate_x(0.55 * time.delta_seconds());
-        transform.rotate_z(0.15 * time.delta_seconds());
+        transform.rotate_x(Angle::radians(0.55 * time.delta_seconds()));
+        transform.rotate_z(Angle::radians(0.15 * time.delta_seconds()));
     }
 }
 
diff --git a/examples/stress_tests/many_cubes.rs b/examples/stress_tests/many_cubes.rs
index 6a1542a025fab..82c2a5baa2611 100644
--- a/examples/stress_tests/many_cubes.rs
+++ b/examples/stress_tests/many_cubes.rs
@@ -267,12 +267,13 @@ fn move_camera(
     mut camera_query: Query<&mut Transform, With<Camera>>,
 ) {
     let mut camera_transform = camera_query.single_mut();
-    let delta = 0.15
-        * if args.benchmark {
+    let delta = Angle::radians(
+        0.15 * if args.benchmark {
             1.0 / 60.0
         } else {
             time.delta_seconds()
-        };
+        },
+    );
     camera_transform.rotate_z(delta);
     camera_transform.rotate_x(delta);
 }
diff --git a/examples/stress_tests/many_foxes.rs b/examples/stress_tests/many_foxes.rs
index 1c75de1bc95c1..64d01acaf0b5a 100644
--- a/examples/stress_tests/many_foxes.rs
+++ b/examples/stress_tests/many_foxes.rs
@@ -147,7 +147,7 @@ fn setup(
 
         let circumference = PI * 2. * radius;
         let foxes_in_ring = ((circumference / FOX_SPACING) as usize).min(foxes_remaining);
-        let fox_spacing_angle = circumference / (foxes_in_ring as f32 * radius);
+        let fox_spacing_angle = Angle::radians(circumference / (foxes_in_ring as f32 * radius));
 
         for fox_i in 0..foxes_in_ring {
             let fox_angle = fox_i as f32 * fox_spacing_angle;
@@ -159,7 +159,9 @@ fn setup(
                     scene: fox_handle.clone(),
                     transform: Transform::from_xyz(x, 0.0, z)
                         .with_scale(Vec3::splat(0.01))
-                        .with_rotation(base_rotation * Quat::from_rotation_y(-fox_angle)),
+                        .with_rotation(
+                            base_rotation * Quat::from_rotation_y(-fox_angle.as_radians()),
+                        ),
                     ..default()
                 });
             });
@@ -242,7 +244,7 @@ fn update_fox_rings(
 
     let dt = time.delta_seconds();
     for (ring, rotation_direction, mut transform) in &mut rings {
-        let angular_velocity = foxes.speed / ring.radius;
+        let angular_velocity = Angle::radians(foxes.speed / ring.radius);
         transform.rotate_y(rotation_direction.sign() * angular_velocity * dt);
     }
 }
diff --git a/examples/stress_tests/many_gizmos.rs b/examples/stress_tests/many_gizmos.rs
index 20296f9f91ae4..034cd6a34ba00 100644
--- a/examples/stress_tests/many_gizmos.rs
+++ b/examples/stress_tests/many_gizmos.rs
@@ -61,7 +61,7 @@ fn system(config: Res<Config>, time: Res<Time>, mut draw: Gizmos) {
         }
     } else {
         for i in 0..(config.line_count / SYSTEM_COUNT) {
-            let angle = i as f32 / (config.line_count / SYSTEM_COUNT) as f32 * TAU;
+            let angle = Angle::radians(i as f32 / (config.line_count / SYSTEM_COUNT) as f32 * TAU);
 
             let vector = Vec2::from(angle.sin_cos()).extend(time.elapsed_seconds().sin());
             let start_color = Color::rgb(vector.x, vector.z, 0.5);
diff --git a/examples/stress_tests/many_lights.rs b/examples/stress_tests/many_lights.rs
index c36a04920c792..61f860c4edd6a 100644
--- a/examples/stress_tests/many_lights.rs
+++ b/examples/stress_tests/many_lights.rs
@@ -135,7 +135,7 @@ fn spherical_polar_to_cartesian(p: DVec2) -> DVec3 {
 // System for rotating the camera
 fn move_camera(time: Res<Time>, mut camera_query: Query<&mut Transform, With<Camera>>) {
     let mut camera_transform = camera_query.single_mut();
-    let delta = time.delta_seconds() * 0.15;
+    let delta = Angle::radians(time.delta_seconds() * 0.15);
     camera_transform.rotate_z(delta);
     camera_transform.rotate_x(delta);
 }
diff --git a/examples/stress_tests/many_sprites.rs b/examples/stress_tests/many_sprites.rs
index a357fbba057e2..fc6fb813edc3e 100644
--- a/examples/stress_tests/many_sprites.rs
+++ b/examples/stress_tests/many_sprites.rs
@@ -101,7 +101,7 @@ fn setup(mut commands: Commands, assets: Res<AssetServer>, color_tint: Res<Color
 // System for rotating and translating the camera
 fn move_camera(time: Res<Time>, mut camera_query: Query<&mut Transform, With<Camera>>) {
     let mut camera_transform = camera_query.single_mut();
-    camera_transform.rotate_z(time.delta_seconds() * 0.5);
+    camera_transform.rotate_z(Angle::radians(time.delta_seconds() * 0.5));
     *camera_transform = *camera_transform
         * Transform::from_translation(Vec3::X * CAMERA_SPEED * time.delta_seconds());
 }
diff --git a/examples/stress_tests/transform_hierarchy.rs b/examples/stress_tests/transform_hierarchy.rs
index 3e6064971e79a..533a89a279c76 100644
--- a/examples/stress_tests/transform_hierarchy.rs
+++ b/examples/stress_tests/transform_hierarchy.rs
@@ -19,6 +19,7 @@
 //! | `humanoids_mixed`    | 2000 active and 2000 inactive humanoid rigs.                      |
 
 use bevy::prelude::*;
+use bevy_internal::math::Angle;
 use rand::Rng;
 
 /// pre-defined test configurations with name
@@ -247,12 +248,12 @@ struct UpdateValue(f32);
 fn update(time: Res<Time>, mut query: Query<(&mut Transform, &mut UpdateValue)>) {
     for (mut t, mut u) in &mut query {
         u.0 += time.delta_seconds() * 0.1;
-        set_translation(&mut t.translation, u.0);
+        set_translation(&mut t.translation, Angle::radians(u.0));
     }
 }
 
 /// set translation based on the angle `a`
-fn set_translation(translation: &mut Vec3, a: f32) {
+fn set_translation(translation: &mut Vec3, a: Angle<f32>) {
     translation.x = a.cos() * 32.0;
     translation.y = a.sin() * 32.0;
 }
@@ -409,7 +410,7 @@ fn spawn_tree(
                 let mut translation = Vec3::ZERO;
                 // use the same placement fn as the `update` system
                 // this way the entities won't be all at (0, 0, 0) when they don't have an `Update` component
-                set_translation(&mut translation, sep);
+                set_translation(&mut translation, Angle::radians(sep));
                 Transform::from_translation(translation)
             };
 
diff --git a/examples/tools/gamepad_viewer.rs b/examples/tools/gamepad_viewer.rs
index 29ef2c5af2386..a891eab8bf3ae 100644
--- a/examples/tools/gamepad_viewer.rs
+++ b/examples/tools/gamepad_viewer.rs
@@ -1,7 +1,5 @@
 //! Shows a visualization of gamepad buttons, sticks, and triggers
 
-use std::f32::consts::PI;
-
 use bevy::{
     input::gamepad::{
         GamepadAxisChangedEvent, GamepadButton, GamepadButtonChangedEvent, GamepadSettings,
@@ -9,6 +7,7 @@ use bevy::{
     prelude::*,
     sprite::{Anchor, MaterialMesh2dBundle, Mesh2dHandle},
 };
+use bevy_internal::math::Angle;
 
 const BUTTON_RADIUS: f32 = 25.;
 const BUTTON_CLUSTER_RADIUS: f32 = 50.;
@@ -107,8 +106,8 @@ impl GamepadButtonBundle {
         }
     }
 
-    pub fn with_rotation(mut self, angle: f32) -> Self {
-        self.mesh_bundle.transform.rotation = Quat::from_rotation_z(angle);
+    pub fn with_rotation(mut self, angle: Angle<f32>) -> Self {
+        self.mesh_bundle.transform.rotation = Quat::from_rotation_z(angle.as_radians());
         self
     }
 }
@@ -216,7 +215,7 @@ fn setup(mut commands: Commands, meshes: Res<ButtonMeshes>, materials: Res<Butto
                     0.,
                     -BUTTON_CLUSTER_RADIUS,
                 )
-                .with_rotation(PI),
+                .with_rotation(Angle::PI),
             );
             parent.spawn(
                 GamepadButtonBundle::new(
@@ -226,7 +225,7 @@ fn setup(mut commands: Commands, meshes: Res<ButtonMeshes>, materials: Res<Butto
                     -BUTTON_CLUSTER_RADIUS,
                     0.,
                 )
-                .with_rotation(PI / 2.),
+                .with_rotation(Angle::FRAC_PI_2),
             );
             parent.spawn(
                 GamepadButtonBundle::new(
@@ -236,7 +235,7 @@ fn setup(mut commands: Commands, meshes: Res<ButtonMeshes>, materials: Res<Butto
                     BUTTON_CLUSTER_RADIUS,
                     0.,
                 )
-                .with_rotation(-PI / 2.),
+                .with_rotation(-Angle::FRAC_PI_2),
             );
         });
 
diff --git a/examples/transforms/3d_rotation.rs b/examples/transforms/3d_rotation.rs
index ddedbbae859e9..7e0196329cbd5 100644
--- a/examples/transforms/3d_rotation.rs
+++ b/examples/transforms/3d_rotation.rs
@@ -7,7 +7,7 @@ use std::f32::consts::TAU;
 // Define a component to designate a rotation speed to an entity.
 #[derive(Component)]
 struct Rotatable {
-    speed: f32,
+    speed: Angle<f32>,
 }
 
 fn main() {
@@ -31,7 +31,9 @@ fn setup(
             transform: Transform::from_translation(Vec3::ZERO),
             ..default()
         },
-        Rotatable { speed: 0.3 },
+        Rotatable {
+            speed: Angle::radians(0.3),
+        },
     ));
 
     // Spawn a camera looking at the entities to show what's happening in this example.
diff --git a/examples/window/low_power.rs b/examples/window/low_power.rs
index 00a211cf0637f..91ca29c704af5 100644
--- a/examples/window/low_power.rs
+++ b/examples/window/low_power.rs
@@ -117,8 +117,8 @@ pub(crate) mod test_setup {
         mut cube_transform: Query<&mut Transform, With<Rotator>>,
     ) {
         for mut transform in &mut cube_transform {
-            transform.rotate_x(time.delta_seconds());
-            transform.rotate_local_y(time.delta_seconds());
+            transform.rotate_x(Angle::radians(time.delta_seconds()));
+            transform.rotate_local_y(Angle::radians(time.delta_seconds()));
         }
     }
 

From edf342acc36309a378464b5cce60ce72236d81dc Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 00:55:13 +0200
Subject: [PATCH 02/21] Add `Angle::max`

---
 crates/bevy_math/src/angle.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_math/src/angle.rs b/crates/bevy_math/src/angle.rs
index 2bc8565c96ef3..2b18ba5eb19ab 100644
--- a/crates/bevy_math/src/angle.rs
+++ b/crates/bevy_math/src/angle.rs
@@ -114,7 +114,13 @@ impl<T: Float> Angle<T> {
     /// Returns the minimum of the two angles, ignoring NaN.
     #[inline]
     pub fn min(&self, other: Self) -> Self {
-        Angle::radians(self.0.min(other.0))
+        Self(self.0.min(other.0))
+    }
+
+    /// Returns the maximum of the two angles, ignoring NaN.
+    #[inline]
+    pub fn max(&self, other: Self) -> Self {
+        Self(self.0.max(other.0))
     }
 }
 

From a59962ba54b45efa6d86d290f0d7444de93983c8 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 13:35:49 +0200
Subject: [PATCH 03/21] Remove generics from `Angle` for now and improve API
 and docs

---
 crates/bevy_gizmos/src/arcs.rs                |  12 +-
 crates/bevy_input/src/touch.rs                |   4 +-
 crates/bevy_math/src/angle.rs                 | 216 +++++++++---------
 crates/bevy_math/src/float.rs                 | 161 -------------
 crates/bevy_math/src/lib.rs                   |   1 -
 crates/bevy_pbr/src/light.rs                  |   6 +-
 crates/bevy_pbr/src/render/light.rs           |   4 +-
 crates/bevy_reflect/src/impls/angle.rs        |   3 +-
 .../src/components/transform.rs               |  16 +-
 crates/bevy_winit/src/converters.rs           |   4 +-
 examples/3d/deferred_rendering.rs             |   2 +-
 examples/3d/parallax_mapping.rs               |   2 +-
 examples/games/contributors.rs                |   2 +-
 examples/stress_tests/transform_hierarchy.rs  |   2 +-
 examples/tools/gamepad_viewer.rs              |   2 +-
 examples/transforms/3d_rotation.rs            |   2 +-
 16 files changed, 140 insertions(+), 299 deletions(-)
 delete mode 100644 crates/bevy_math/src/float.rs

diff --git a/crates/bevy_gizmos/src/arcs.rs b/crates/bevy_gizmos/src/arcs.rs
index bd779c17ebc3b..a35ca16c2e2c7 100644
--- a/crates/bevy_gizmos/src/arcs.rs
+++ b/crates/bevy_gizmos/src/arcs.rs
@@ -42,8 +42,8 @@ impl<'s> Gizmos<'s> {
     pub fn arc_2d(
         &mut self,
         position: Vec2,
-        direction_angle: Angle<f32>,
-        arc_angle: Angle<f32>,
+        direction_angle: Angle,
+        arc_angle: Angle,
         radius: f32,
         color: Color,
     ) -> Arc2dBuilder<'_, 's> {
@@ -63,8 +63,8 @@ impl<'s> Gizmos<'s> {
 pub struct Arc2dBuilder<'a, 's> {
     gizmos: &'a mut Gizmos<'s>,
     position: Vec2,
-    direction_angle: Angle<f32>,
-    arc_angle: Angle<f32>,
+    direction_angle: Angle,
+    arc_angle: Angle,
     radius: f32,
     color: Color,
     segments: Option<usize>,
@@ -95,8 +95,8 @@ impl Drop for Arc2dBuilder<'_, '_> {
 }
 
 fn arc_inner(
-    direction_angle: Angle<f32>,
-    arc_angle: Angle<f32>,
+    direction_angle: Angle,
+    arc_angle: Angle,
     radius: f32,
     segments: usize,
 ) -> impl Iterator<Item = Vec2> {
diff --git a/crates/bevy_input/src/touch.rs b/crates/bevy_input/src/touch.rs
index 19b2a302e02ee..be8235fec0253 100644
--- a/crates/bevy_input/src/touch.rs
+++ b/crates/bevy_input/src/touch.rs
@@ -2,7 +2,7 @@
 
 use bevy_ecs::event::{Event, EventReader};
 use bevy_ecs::system::{ResMut, Resource};
-use bevy_math::{Angle, Vec2};
+use bevy_math::Vec2;
 use bevy_reflect::Reflect;
 use bevy_utils::HashMap;
 
@@ -83,7 +83,7 @@ pub enum ForceTouch {
         /// A value of 0 radians indicates that the stylus is parallel to the
         /// surface. The value of this property is Pi/2 when the stylus is
         /// perpendicular to the surface.
-        altitude_angle: Option<Angle<f64>>,
+        altitude_angle: Option<f64>,
     },
     /// If the platform reports the force as normalized, we have no way of
     /// knowing how much pressure 1.0 corresponds to – we know it's the maximum
diff --git a/crates/bevy_math/src/angle.rs b/crates/bevy_math/src/angle.rs
index 2b18ba5eb19ab..87f508fdfccbe 100644
--- a/crates/bevy_math/src/angle.rs
+++ b/crates/bevy_math/src/angle.rs
@@ -3,128 +3,156 @@ use std::{
     ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign},
 };
 
-use super::{float::Float, Vec2};
-use glam::DVec2;
-
 /// An angle in radians.
+///
+/// # Example
+///
+/// ```
+/// use std::f32::consts::PI;
+/// use bevy_math::Angle;
+///
+/// // Create angles from radians or degrees
+/// let alpha = Angle::radians(PI);
+/// let beta = Angle::degrees(180.0);
+/// assert_eq!(alpha, beta);
+///
+/// // Get float values
+/// assert_eq!(alpha.as_radians(), PI);
+/// assert_eq!(alpha.as_degrees(), 180.0);
+///
+/// // Use trigonometric operations
+/// assert_eq!(alpha.cos(), -1.0);
+///
+/// // Wrap 3pi to range [-2pi, 2pi) to get pi
+/// let gamma = 3.0 * alpha;
+/// let wrapped = gamma.wrap();
+///
+/// // Small threshold for floating point error
+/// assert!((wrapped - alpha).abs() < Angle::radians(0.000001));
+/// ```
 #[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
-pub struct Angle<T: Float>(T);
+pub struct Angle(f32);
 
-impl<T: Float> Default for Angle<T> {
+impl Default for Angle {
     fn default() -> Self {
         Self::ZERO
     }
 }
 
-impl Angle<f32> {
-    /// Rotates the given vector by `self`.
-    #[inline]
-    pub fn rotate(&self, vec: Vec2) -> Vec2 {
-        Vec2::new(
-            vec.x * self.sin() + vec.y * self.cos(),
-            vec.x * self.cos() - vec.y * self.sin(),
-        )
-    }
-}
-
-impl Angle<f64> {
-    /// Rotates the given vector by `self`.
-    #[inline]
-    pub fn rotate(&self, vec: DVec2) -> DVec2 {
-        DVec2::new(
-            vec.x * self.sin() + vec.y * self.cos(),
-            vec.x * self.cos() - vec.y * self.sin(),
-        )
-    }
-}
-
-impl<T: Float> Angle<T> {
+impl Angle {
     /// An angle of zero.
-    pub const ZERO: Self = Self(T::ZERO);
+    pub const ZERO: Self = Self(0.0);
     /// The angle 2π in radians.
-    pub const TAU: Self = Self(T::TAU);
+    #[doc(alias = "TWO_PI")]
+    pub const TAU: Self = Self(std::f32::consts::TAU);
     /// The angle π (pi) in radians.
-    pub const PI: Self = Self(T::PI);
+    pub const PI: Self = Self(std::f32::consts::PI);
     /// The angle π/2 in radians.
-    pub const FRAC_PI_2: Self = Self(T::FRAC_PI_2);
+    #[doc(alias = "HALF_PI")]
+    pub const FRAC_PI_2: Self = Self(std::f32::consts::FRAC_PI_2);
     /// The angle π/3 in radians.
-    pub const FRAC_PI_3: Self = Self(T::FRAC_PI_3);
+    pub const FRAC_PI_3: Self = Self(std::f32::consts::FRAC_PI_3);
     /// The angle π/4 in radians.
-    pub const FRAC_PI_4: Self = Self(T::FRAC_PI_4);
+    pub const FRAC_PI_4: Self = Self(std::f32::consts::FRAC_PI_4);
     /// The angle π/6 in radians.
-    pub const FRAC_PI_6: Self = Self(T::FRAC_PI_6);
+    pub const FRAC_PI_6: Self = Self(std::f32::consts::FRAC_PI_6);
     /// The angle π/8 in radians.
-    pub const FRAC_PI_8: Self = Self(T::FRAC_PI_8);
+    pub const FRAC_PI_8: Self = Self(std::f32::consts::FRAC_PI_8);
 
     /// Returns the sine of the angle in radians.
     #[inline]
-    pub fn sin(&self) -> T {
+    pub fn sin(self) -> f32 {
         self.0.sin()
     }
 
     /// Returns the cosine of the angle in radians.
     #[inline]
-    pub fn cos(&self) -> T {
+    pub fn cos(self) -> f32 {
         self.0.cos()
     }
 
     /// Returns the tangent of the angle in radians.
     #[inline]
-    pub fn tan(&self) -> T {
+    pub fn tan(self) -> f32 {
         self.0.tan()
     }
 
     /// Returns the sine and cosine of the angle in radians.
     #[inline]
-    pub fn sin_cos(&self) -> (T, T) {
+    pub fn sin_cos(self) -> (f32, f32) {
         self.0.sin_cos()
     }
 
     /// Creates an [`Angle`] from radians.
     #[inline]
-    pub const fn radians(radians: T) -> Self {
+    pub const fn radians(radians: f32) -> Self {
         Self(radians)
     }
 
     /// Creates an [`Angle`] from degrees.
     #[inline]
-    pub fn degrees(degrees: T) -> Self {
+    pub fn degrees(degrees: f32) -> Self {
         Self(degrees.to_radians())
     }
 
     /// Returns the angle in radians.
     #[inline]
-    pub fn as_radians(&self) -> T {
+    pub fn as_radians(self) -> f32 {
         self.0
     }
 
     /// Returns the angle in degrees.
     #[inline]
-    pub fn as_degrees(&self) -> T {
-        self.as_radians().to_degrees()
+    pub fn as_degrees(self) -> f32 {
+        self.0.to_degrees()
     }
 
     /// Returns the absolute angle.
     #[inline]
-    pub fn abs(&self) -> Self {
+    pub fn abs(self) -> Self {
         Self(self.0.abs())
     }
 
     /// Returns the minimum of the two angles, ignoring NaN.
     #[inline]
-    pub fn min(&self, other: Self) -> Self {
+    pub fn min(self, other: Self) -> Self {
         Self(self.0.min(other.0))
     }
 
     /// Returns the maximum of the two angles, ignoring NaN.
     #[inline]
-    pub fn max(&self, other: Self) -> Self {
+    pub fn max(self, other: Self) -> Self {
         Self(self.0.max(other.0))
     }
+
+    /// Wraps the angle to be within the `[-2pi, 2pi)` range.
+    #[inline]
+    pub fn wrap(self) -> Self {
+        Self(self.0 % std::f32::consts::TAU)
+    }
+
+    /// Returns the largest integer angle less than or equal to `self`.
+    #[inline]
+    pub fn floor(self) -> Self {
+        Self(self.0.floor())
+    }
+
+    /// Returns the smallest integer angle greater than or equal to `self`.
+    #[inline]
+    pub fn ceil(self) -> Self {
+        Self(self.0.ceil())
+    }
+
+    /// Returns the nearest integer to `self`. If a value is half-way
+    /// between two integers, round away from `0.0`.
+    #[inline]
+    pub fn round(self) -> Self {
+        Self(self.0.round())
+    }
 }
 
-impl<T: Float> Add for Angle<T> {
+impl Add for Angle {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self::Output {
@@ -132,7 +160,7 @@ impl<T: Float> Add for Angle<T> {
     }
 }
 
-impl<T: Float> Sub for Angle<T> {
+impl Sub for Angle {
     type Output = Self;
 
     fn sub(self, rhs: Self) -> Self::Output {
@@ -140,71 +168,47 @@ impl<T: Float> Sub for Angle<T> {
     }
 }
 
-impl<T: Float> Mul for Angle<T> {
+impl Mul for Angle {
     type Output = Self;
 
-    fn mul(self, rhs: Self) -> Self::Output {
+    fn mul(self, rhs: Angle) -> Self::Output {
         Self(self.0 * rhs.0)
     }
 }
 
-impl<T: Float> Div for Angle<T> {
-    type Output = Self;
-
-    fn div(self, rhs: Self) -> Self::Output {
-        Self(self.0 / rhs.0)
-    }
-}
-
-impl<T: Float> Mul<T> for Angle<T> {
+impl Mul<f32> for Angle {
     type Output = Self;
 
-    fn mul(self, rhs: T) -> Self::Output {
+    fn mul(self, rhs: f32) -> Self::Output {
         Self(self.0 * rhs)
     }
 }
 
-impl Mul<Angle<f32>> for f32 {
-    type Output = Angle<f32>;
+impl Mul<Angle> for f32 {
+    type Output = Angle;
 
-    fn mul(self, rhs: Angle<f32>) -> Self::Output {
-        Angle::radians(self * rhs.as_radians())
+    fn mul(self, rhs: Angle) -> Self::Output {
+        Angle::radians(self * rhs.0)
     }
 }
 
-impl Mul<Angle<f64>> for f64 {
-    type Output = Angle<f64>;
-
-    fn mul(self, rhs: Angle<f64>) -> Self::Output {
-        Angle::radians(self * rhs.as_radians())
-    }
-}
-
-impl<T: Float> Div<T> for Angle<T> {
+impl Div for Angle {
     type Output = Self;
 
-    fn div(self, rhs: T) -> Self::Output {
-        Self::radians(self.as_radians() / rhs)
-    }
-}
-
-impl Div<Angle<f32>> for f32 {
-    type Output = Angle<f32>;
-
-    fn div(self, rhs: Angle<f32>) -> Self::Output {
-        Angle::radians(self / rhs.as_radians())
+    fn div(self, rhs: Self) -> Self::Output {
+        Self(self.0 / rhs.0)
     }
 }
 
-impl Div<Angle<f64>> for f64 {
-    type Output = Angle<f64>;
+impl Div<f32> for Angle {
+    type Output = Self;
 
-    fn div(self, rhs: Angle<f64>) -> Self::Output {
-        Angle::radians(self / rhs.as_radians())
+    fn div(self, rhs: f32) -> Self::Output {
+        Self(self.0 / rhs)
     }
 }
 
-impl<T: Float> Neg for Angle<T> {
+impl Neg for Angle {
     type Output = Self;
 
     fn neg(self) -> Self::Output {
@@ -212,50 +216,50 @@ impl<T: Float> Neg for Angle<T> {
     }
 }
 
-impl<T: Float> AddAssign<Angle<T>> for Angle<T> {
-    fn add_assign(&mut self, rhs: Angle<T>) {
+impl AddAssign<Angle> for Angle {
+    fn add_assign(&mut self, rhs: Angle) {
         self.0 += rhs.0;
     }
 }
 
-impl<T: Float> SubAssign<Angle<T>> for Angle<T> {
-    fn sub_assign(&mut self, rhs: Angle<T>) {
+impl SubAssign<Angle> for Angle {
+    fn sub_assign(&mut self, rhs: Angle) {
         self.0 -= rhs.0;
     }
 }
 
-impl<T: Float> MulAssign<Angle<T>> for Angle<T> {
-    fn mul_assign(&mut self, rhs: Angle<T>) {
+impl MulAssign<Angle> for Angle {
+    fn mul_assign(&mut self, rhs: Angle) {
         self.0 *= rhs.0;
     }
 }
 
-impl<T: Float> DivAssign<Angle<T>> for Angle<T> {
-    fn div_assign(&mut self, rhs: Angle<T>) {
+impl DivAssign<Angle> for Angle {
+    fn div_assign(&mut self, rhs: Angle) {
         self.0 /= rhs.0;
     }
 }
 
-impl<T: Float> AddAssign<T> for Angle<T> {
-    fn add_assign(&mut self, rhs: T) {
+impl AddAssign<f32> for Angle {
+    fn add_assign(&mut self, rhs: f32) {
         self.0 += rhs;
     }
 }
 
-impl<T: Float> SubAssign<T> for Angle<T> {
-    fn sub_assign(&mut self, rhs: T) {
+impl SubAssign<f32> for Angle {
+    fn sub_assign(&mut self, rhs: f32) {
         self.0 -= rhs;
     }
 }
 
-impl<T: Float> MulAssign<T> for Angle<T> {
-    fn mul_assign(&mut self, rhs: T) {
+impl MulAssign<f32> for Angle {
+    fn mul_assign(&mut self, rhs: f32) {
         self.0 *= rhs;
     }
 }
 
-impl<T: Float> DivAssign<T> for Angle<T> {
-    fn div_assign(&mut self, rhs: T) {
+impl DivAssign<f32> for Angle {
+    fn div_assign(&mut self, rhs: f32) {
         self.0 /= rhs;
     }
 }
diff --git a/crates/bevy_math/src/float.rs b/crates/bevy_math/src/float.rs
deleted file mode 100644
index 2b44dd12484a6..0000000000000
--- a/crates/bevy_math/src/float.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-//! Contains a generic trait for floating-point numbers.
-
-use std::{
-    fmt::Debug,
-    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign},
-};
-
-/// A trait for generic floats.
-pub trait Float:
-    Sized
-    + Clone
-    + Copy
-    + Debug
-    + Default
-    + PartialEq<Self>
-    + PartialOrd<Self>
-    + Add<Self, Output = Self>
-    + Sub<Self, Output = Self>
-    + Mul<Self, Output = Self>
-    + Div<Self, Output = Self>
-    + AddAssign<Self>
-    + SubAssign<Self>
-    + MulAssign<Self>
-    + DivAssign<Self>
-    + Neg<Output = Self>
-{
-    /// A value of 0.
-    const ZERO: Self;
-    /// A value of 1.
-    const ONE: Self;
-    /// A value of -1.
-    const NEG_ONE: Self;
-    /// 2π
-    const TAU: Self;
-    /// π (pi)
-    const PI: Self;
-    /// π/2
-    const FRAC_PI_2: Self;
-    /// π/3
-    const FRAC_PI_3: Self;
-    /// π/4
-    const FRAC_PI_4: Self;
-    /// π/6
-    const FRAC_PI_6: Self;
-    /// π/8
-    const FRAC_PI_8: Self;
-
-    /// Computes the sine of a number (in radians).
-    fn sin(self) -> Self;
-    /// Computes the cosine of a number (in radians).
-    fn cos(self) -> Self;
-    /// Computes the tangent of a number (in radians).
-    fn tan(self) -> Self;
-    /// Simultaneously computes the sine and cosine of the number, `x`. Returns `(sin(x), cos(x))`.
-    fn sin_cos(self) -> (Self, Self);
-    /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`) in radians.
-    ///
-    /// - `x = 0`, `y = 0`: `0`
-    /// - `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
-    /// - `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
-    /// - `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
-    fn atan2(self, other: Self) -> Self;
-    /// Converts radians to degrees.
-    fn to_degrees(self) -> Self;
-    /// Converts degrees to radians.
-    fn to_radians(self) -> Self;
-    /// Computes the absolute value of `self`.
-    fn abs(self) -> Self;
-    /// Returns the minimum of the two numbers, ignoring NaN.
-    fn min(self, other: Self) -> Self;
-    /// Returns the maximum of the two numbers, ignoring NaN.
-    fn max(self, other: Self) -> Self;
-}
-
-impl Float for f32 {
-    const ZERO: Self = 0.0;
-    const ONE: Self = 1.0;
-    const NEG_ONE: Self = -1.0;
-    const TAU: Self = std::f32::consts::TAU;
-    const PI: Self = std::f32::consts::PI;
-    const FRAC_PI_2: Self = std::f32::consts::FRAC_PI_2;
-    const FRAC_PI_3: Self = std::f32::consts::FRAC_PI_3;
-    const FRAC_PI_4: Self = std::f32::consts::FRAC_PI_4;
-    const FRAC_PI_6: Self = std::f32::consts::FRAC_PI_6;
-    const FRAC_PI_8: Self = std::f32::consts::FRAC_PI_8;
-
-    fn sin(self) -> Self {
-        self.sin()
-    }
-    fn cos(self) -> Self {
-        self.cos()
-    }
-    fn tan(self) -> Self {
-        self.tan()
-    }
-    fn sin_cos(self) -> (Self, Self) {
-        self.sin_cos()
-    }
-    fn atan2(self, other: Self) -> Self {
-        self.atan2(other)
-    }
-    fn to_degrees(self) -> Self {
-        self.to_degrees()
-    }
-    fn to_radians(self) -> Self {
-        self.to_radians()
-    }
-    fn abs(self) -> Self {
-        self.abs()
-    }
-    fn min(self, other: Self) -> Self {
-        self.min(other)
-    }
-    fn max(self, other: Self) -> Self {
-        self.max(other)
-    }
-}
-
-impl Float for f64 {
-    const ZERO: Self = 0.0;
-    const ONE: Self = 1.0;
-    const NEG_ONE: Self = -1.0;
-    const TAU: Self = std::f64::consts::TAU;
-    const PI: Self = std::f64::consts::PI;
-    const FRAC_PI_2: Self = std::f64::consts::FRAC_PI_2;
-    const FRAC_PI_3: Self = std::f64::consts::FRAC_PI_3;
-    const FRAC_PI_4: Self = std::f64::consts::FRAC_PI_4;
-    const FRAC_PI_6: Self = std::f64::consts::FRAC_PI_6;
-    const FRAC_PI_8: Self = std::f64::consts::FRAC_PI_8;
-
-    fn sin(self) -> Self {
-        self.sin()
-    }
-    fn cos(self) -> Self {
-        self.cos()
-    }
-    fn tan(self) -> Self {
-        self.tan()
-    }
-    fn sin_cos(self) -> (Self, Self) {
-        self.sin_cos()
-    }
-    fn atan2(self, other: Self) -> Self {
-        self.atan2(other)
-    }
-    fn to_degrees(self) -> Self {
-        self.to_degrees()
-    }
-    fn to_radians(self) -> Self {
-        self.to_radians()
-    }
-    fn abs(self) -> Self {
-        self.abs()
-    }
-    fn min(self, other: Self) -> Self {
-        self.min(other)
-    }
-    fn max(self, other: Self) -> Self {
-        self.max(other)
-    }
-}
diff --git a/crates/bevy_math/src/lib.rs b/crates/bevy_math/src/lib.rs
index 751389b41715b..f294d93331eec 100644
--- a/crates/bevy_math/src/lib.rs
+++ b/crates/bevy_math/src/lib.rs
@@ -10,7 +10,6 @@ mod affine3;
 mod angle;
 mod aspect_ratio;
 pub mod cubic_splines;
-pub mod float;
 pub mod primitives;
 mod ray;
 mod rects;
diff --git a/crates/bevy_pbr/src/light.rs b/crates/bevy_pbr/src/light.rs
index 00a5a882dc994..f5b2c8d263649 100644
--- a/crates/bevy_pbr/src/light.rs
+++ b/crates/bevy_pbr/src/light.rs
@@ -107,12 +107,12 @@ pub struct SpotLight {
     /// `outer_angle` should be < `PI / 2.0`.
     /// `PI / 2.0` defines a hemispherical spot light, but shadows become very blocky as the angle
     /// approaches this limit.
-    pub outer_angle: Angle<f32>,
+    pub outer_angle: Angle,
     /// Angle defining the distance from the spot light direction to the inner limit
     /// of the light's cone of effect.
     /// Light is attenuated from `inner_angle` to `outer_angle` to give a smooth falloff.
     /// `inner_angle` should be <= `outer_angle`
-    pub inner_angle: Angle<f32>,
+    pub inner_angle: Angle,
 }
 
 impl SpotLight {
@@ -1155,7 +1155,7 @@ pub(crate) struct PointLightAssignmentData {
     transform: GlobalTransform,
     range: f32,
     shadows_enabled: bool,
-    spot_light_angle: Option<Angle<f32>>,
+    spot_light_angle: Option<Angle>,
     render_layers: RenderLayers,
 }
 
diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
index 9d948b7e53f15..bc8d9f21f16b5 100644
--- a/crates/bevy_pbr/src/render/light.rs
+++ b/crates/bevy_pbr/src/render/light.rs
@@ -35,7 +35,7 @@ pub struct ExtractedPointLight {
     shadows_enabled: bool,
     shadow_depth_bias: f32,
     shadow_normal_bias: f32,
-    spot_light_angles: Option<(Angle<f32>, Angle<f32>)>,
+    spot_light_angles: Option<(Angle, Angle)>,
 }
 
 #[derive(Component, Debug)]
@@ -635,7 +635,7 @@ pub(crate) fn spot_light_view_matrix(transform: &GlobalTransform) -> Mat4 {
     )
 }
 
-pub(crate) fn spot_light_projection_matrix(angle: Angle<f32>) -> Mat4 {
+pub(crate) fn spot_light_projection_matrix(angle: Angle) -> Mat4 {
     // spot light projection FOV is 2x the angle from spot light center to outer edge
     Mat4::perspective_infinite_reverse_rh(angle.as_radians() * 2.0, 1.0, POINT_LIGHT_NEAR_Z)
 }
diff --git a/crates/bevy_reflect/src/impls/angle.rs b/crates/bevy_reflect/src/impls/angle.rs
index a5ec8d63765ca..d00598070459a 100644
--- a/crates/bevy_reflect/src/impls/angle.rs
+++ b/crates/bevy_reflect/src/impls/angle.rs
@@ -1,6 +1,5 @@
 use crate as bevy_reflect;
 use crate::prelude::ReflectDefault;
-use bevy_math::float::Float;
 use bevy_reflect_derive::impl_reflect_value;
 
-impl_reflect_value!(::bevy_math::Angle<T: Float + std::marker::Sync + std::marker::Send>(Debug, Default));
+impl_reflect_value!(::bevy_math::Angle(Debug, Default));
diff --git a/crates/bevy_transform/src/components/transform.rs b/crates/bevy_transform/src/components/transform.rs
index 43a29caadc920..043a45cfed71f 100644
--- a/crates/bevy_transform/src/components/transform.rs
+++ b/crates/bevy_transform/src/components/transform.rs
@@ -256,7 +256,7 @@ impl Transform {
     ///
     /// If this [`Transform`] has a parent, the `axis` is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_axis(&mut self, axis: Vec3, angle: Angle<f32>) {
+    pub fn rotate_axis(&mut self, axis: Vec3, angle: Angle) {
         self.rotate(Quat::from_axis_angle(axis, angle.as_radians()));
     }
 
@@ -264,7 +264,7 @@ impl Transform {
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_x(&mut self, angle: Angle<f32>) {
+    pub fn rotate_x(&mut self, angle: Angle) {
         self.rotate(Quat::from_rotation_x(angle.as_radians()));
     }
 
@@ -272,7 +272,7 @@ impl Transform {
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_y(&mut self, angle: Angle<f32>) {
+    pub fn rotate_y(&mut self, angle: Angle) {
         self.rotate(Quat::from_rotation_y(angle.as_radians()));
     }
 
@@ -280,7 +280,7 @@ impl Transform {
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_z(&mut self, angle: Angle<f32>) {
+    pub fn rotate_z(&mut self, angle: Angle) {
         self.rotate(Quat::from_rotation_z(angle.as_radians()));
     }
 
@@ -294,25 +294,25 @@ impl Transform {
 
     /// Rotates this [`Transform`] around its local `axis` by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_axis(&mut self, axis: Vec3, angle: Angle<f32>) {
+    pub fn rotate_local_axis(&mut self, axis: Vec3, angle: Angle) {
         self.rotate_local(Quat::from_axis_angle(axis, angle.as_radians()));
     }
 
     /// Rotates this [`Transform`] around its local `X` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_x(&mut self, angle: Angle<f32>) {
+    pub fn rotate_local_x(&mut self, angle: Angle) {
         self.rotate_local(Quat::from_rotation_x(angle.as_radians()));
     }
 
     /// Rotates this [`Transform`] around its local `Y` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_y(&mut self, angle: Angle<f32>) {
+    pub fn rotate_local_y(&mut self, angle: Angle) {
         self.rotate_local(Quat::from_rotation_y(angle.as_radians()));
     }
 
     /// Rotates this [`Transform`] around its local `Z` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_z(&mut self, angle: Angle<f32>) {
+    pub fn rotate_local_z(&mut self, angle: Angle) {
         self.rotate_local(Quat::from_rotation_z(angle.as_radians()));
     }
 
diff --git a/crates/bevy_winit/src/converters.rs b/crates/bevy_winit/src/converters.rs
index 1daef6d1334e8..9817d5a4e98ae 100644
--- a/crates/bevy_winit/src/converters.rs
+++ b/crates/bevy_winit/src/converters.rs
@@ -5,7 +5,7 @@ use bevy_input::{
     touch::{ForceTouch, TouchInput, TouchPhase},
     ButtonState,
 };
-use bevy_math::{Angle, Vec2};
+use bevy_math::Vec2;
 use bevy_window::{CursorIcon, EnabledButtons, WindowLevel, WindowTheme};
 
 pub fn convert_keyboard_input(
@@ -57,7 +57,7 @@ pub fn convert_touch_input(
             } => ForceTouch::Calibrated {
                 force,
                 max_possible_force,
-                altitude_angle: altitude_angle.map(Angle::radians),
+                altitude_angle,
             },
             winit::event::Force::Normalized(x) => ForceTouch::Normalized(x),
         }),
diff --git a/examples/3d/deferred_rendering.rs b/examples/3d/deferred_rendering.rs
index 03c7c3261ff68..921eb52c026ff 100644
--- a/examples/3d/deferred_rendering.rs
+++ b/examples/3d/deferred_rendering.rs
@@ -311,7 +311,7 @@ fn update_normal(
 
 #[derive(Component)]
 struct Spin {
-    speed: Angle<f32>,
+    speed: Angle,
 }
 
 fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>, pause: Res<Pause>) {
diff --git a/examples/3d/parallax_mapping.rs b/examples/3d/parallax_mapping.rs
index fb77676a9a6ef..55e8d6d4a9343 100644
--- a/examples/3d/parallax_mapping.rs
+++ b/examples/3d/parallax_mapping.rs
@@ -27,7 +27,7 @@ fn main() {
 
 #[derive(Component)]
 struct Spin {
-    speed: Angle<f32>,
+    speed: Angle,
 }
 
 /// The camera, used to move camera on click.
diff --git a/examples/games/contributors.rs b/examples/games/contributors.rs
index 30ff45796fd19..0339fbd008f38 100644
--- a/examples/games/contributors.rs
+++ b/examples/games/contributors.rs
@@ -64,7 +64,7 @@ struct Contributor {
 #[derive(Component)]
 struct Velocity {
     translation: Vec3,
-    rotation: Angle<f32>,
+    rotation: Angle,
 }
 
 const GRAVITY: f32 = 9.821 * 100.0;
diff --git a/examples/stress_tests/transform_hierarchy.rs b/examples/stress_tests/transform_hierarchy.rs
index 533a89a279c76..16f477cfd9e23 100644
--- a/examples/stress_tests/transform_hierarchy.rs
+++ b/examples/stress_tests/transform_hierarchy.rs
@@ -253,7 +253,7 @@ fn update(time: Res<Time>, mut query: Query<(&mut Transform, &mut UpdateValue)>)
 }
 
 /// set translation based on the angle `a`
-fn set_translation(translation: &mut Vec3, a: Angle<f32>) {
+fn set_translation(translation: &mut Vec3, a: Angle) {
     translation.x = a.cos() * 32.0;
     translation.y = a.sin() * 32.0;
 }
diff --git a/examples/tools/gamepad_viewer.rs b/examples/tools/gamepad_viewer.rs
index a891eab8bf3ae..6f1ca61a217f7 100644
--- a/examples/tools/gamepad_viewer.rs
+++ b/examples/tools/gamepad_viewer.rs
@@ -106,7 +106,7 @@ impl GamepadButtonBundle {
         }
     }
 
-    pub fn with_rotation(mut self, angle: Angle<f32>) -> Self {
+    pub fn with_rotation(mut self, angle: Angle) -> Self {
         self.mesh_bundle.transform.rotation = Quat::from_rotation_z(angle.as_radians());
         self
     }
diff --git a/examples/transforms/3d_rotation.rs b/examples/transforms/3d_rotation.rs
index 7e0196329cbd5..acf421bc6b27d 100644
--- a/examples/transforms/3d_rotation.rs
+++ b/examples/transforms/3d_rotation.rs
@@ -7,7 +7,7 @@ use std::f32::consts::TAU;
 // Define a component to designate a rotation speed to an entity.
 #[derive(Component)]
 struct Rotatable {
-    speed: Angle<f32>,
+    speed: Angle,
 }
 
 fn main() {

From 7de5dfd978e75bdf9cb15832c9256be64608b099 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 13:54:00 +0200
Subject: [PATCH 04/21] Remove `num-traits`

---
 crates/bevy_math/Cargo.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/crates/bevy_math/Cargo.toml b/crates/bevy_math/Cargo.toml
index c3128263e2b41..7ee418a42158e 100644
--- a/crates/bevy_math/Cargo.toml
+++ b/crates/bevy_math/Cargo.toml
@@ -10,7 +10,6 @@ keywords = ["bevy"]
 
 [dependencies]
 glam = { version = "0.24.1", features = ["bytemuck"] }
-num-traits = { version = "0.2.17", default-features = false }
 serde = { version = "1", features = ["derive"], optional = true }
 
 [features]

From 15f44b2a7e393c05a3010f1a6fc5b79a94935433 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 13:54:44 +0200
Subject: [PATCH 05/21] Add `normalize` doc alias for `Angle::wrap` and derive
 `Default`

---
 crates/bevy_math/src/angle.rs | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_math/src/angle.rs b/crates/bevy_math/src/angle.rs
index 87f508fdfccbe..2e6235b0829fd 100644
--- a/crates/bevy_math/src/angle.rs
+++ b/crates/bevy_math/src/angle.rs
@@ -30,16 +30,10 @@ use std::{
 /// // Small threshold for floating point error
 /// assert!((wrapped - alpha).abs() < Angle::radians(0.000001));
 /// ```
-#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 pub struct Angle(f32);
 
-impl Default for Angle {
-    fn default() -> Self {
-        Self::ZERO
-    }
-}
-
 impl Angle {
     /// An angle of zero.
     pub const ZERO: Self = Self(0.0);
@@ -128,6 +122,7 @@ impl Angle {
 
     /// Wraps the angle to be within the `[-2pi, 2pi)` range.
     #[inline]
+    #[doc(alias = "normalize")]
     pub fn wrap(self) -> Self {
         Self(self.0 % std::f32::consts::TAU)
     }

From 5ad466f9ddf67dc7bbb9ba5dc6a64fe7f77f9a11 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 14:18:25 +0200
Subject: [PATCH 06/21] Reflect more

---
 crates/bevy_reflect/src/impls/angle.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_reflect/src/impls/angle.rs b/crates/bevy_reflect/src/impls/angle.rs
index d00598070459a..7011a47bb1eae 100644
--- a/crates/bevy_reflect/src/impls/angle.rs
+++ b/crates/bevy_reflect/src/impls/angle.rs
@@ -1,5 +1,11 @@
-use crate as bevy_reflect;
 use crate::prelude::ReflectDefault;
+use crate::{self as bevy_reflect, ReflectDeserialize, ReflectSerialize};
 use bevy_reflect_derive::impl_reflect_value;
 
-impl_reflect_value!(::bevy_math::Angle(Debug, Default));
+impl_reflect_value!(::bevy_math::Angle(
+    Debug,
+    Default,
+    PartialEq,
+    Serialize,
+    Deserialize,
+));

From ca8d3f3ecf7cce703dba17c364f4df96b0f2e945 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 17:33:19 +0200
Subject: [PATCH 07/21] Add separate `Degrees` and `Radians` structs and an
 `Angle` trait

---
 crates/bevy_gizmos/src/arcs.rs                |  21 +-
 crates/bevy_gizmos/src/circles.rs             |   4 +-
 crates/bevy_gltf/src/loader.rs                |   6 +-
 crates/bevy_math/src/angle.rs                 | 260 ----------------
 crates/bevy_math/src/angle/degrees.rs         | 239 +++++++++++++++
 crates/bevy_math/src/angle/mod.rs             | 268 ++++++++++++++++
 crates/bevy_math/src/angle/radians.rs         | 288 ++++++++++++++++++
 crates/bevy_math/src/lib.rs                   |   7 +-
 crates/bevy_pbr/src/light.rs                  |  13 +-
 crates/bevy_pbr/src/render/light.rs           |   8 +-
 crates/bevy_reflect/src/impls/angle.rs        |   2 +-
 .../src/components/transform.rs               |  34 +--
 examples/2d/2d_gizmos.rs                      |   4 +-
 examples/2d/pixel_grid_snap.rs                |   2 +-
 examples/2d/rotation.rs                       |   7 +-
 examples/3d/3d_shapes.rs                      |   2 +-
 examples/3d/deferred_rendering.rs             |   6 +-
 examples/3d/generate_custom_mesh.rs           |   6 +-
 examples/3d/lighting.rs                       |  12 +-
 examples/3d/parallax_mapping.rs               |   6 +-
 examples/3d/parenting.rs                      |   2 +-
 examples/3d/render_to_texture.rs              |   8 +-
 examples/3d/skybox.rs                         |   2 +-
 examples/3d/spotlight.rs                      |   7 +-
 examples/ecs/hierarchy.rs                     |   4 +-
 examples/games/alien_cake_addict.rs           |   2 +-
 examples/games/contributors.rs                |   4 +-
 examples/shader/post_processing.rs            |   4 +-
 examples/stress_tests/many_cubes.rs           |   2 +-
 examples/stress_tests/many_foxes.rs           |   8 +-
 examples/stress_tests/many_gizmos.rs          |   2 +-
 examples/stress_tests/many_lights.rs          |   2 +-
 examples/stress_tests/many_sprites.rs         |   2 +-
 examples/stress_tests/transform_hierarchy.rs  |   8 +-
 examples/tools/gamepad_viewer.rs              |  12 +-
 examples/transforms/3d_rotation.rs            |   4 +-
 examples/window/low_power.rs                  |   4 +-
 37 files changed, 902 insertions(+), 370 deletions(-)
 delete mode 100644 crates/bevy_math/src/angle.rs
 create mode 100644 crates/bevy_math/src/angle/degrees.rs
 create mode 100644 crates/bevy_math/src/angle/mod.rs
 create mode 100644 crates/bevy_math/src/angle/radians.rs

diff --git a/crates/bevy_gizmos/src/arcs.rs b/crates/bevy_gizmos/src/arcs.rs
index a35ca16c2e2c7..21b4d47dbdef7 100644
--- a/crates/bevy_gizmos/src/arcs.rs
+++ b/crates/bevy_gizmos/src/arcs.rs
@@ -5,7 +5,7 @@
 
 use crate::circles::DEFAULT_CIRCLE_SEGMENTS;
 use crate::prelude::Gizmos;
-use bevy_math::{Angle, Vec2};
+use bevy_math::{Angle, Radians, Vec2};
 use bevy_render::color::Color;
 use std::f32::consts::TAU;
 
@@ -42,16 +42,16 @@ impl<'s> Gizmos<'s> {
     pub fn arc_2d(
         &mut self,
         position: Vec2,
-        direction_angle: Angle,
-        arc_angle: Angle,
+        direction_angle: impl Into<Radians>,
+        arc_angle: impl Into<Radians>,
         radius: f32,
         color: Color,
     ) -> Arc2dBuilder<'_, 's> {
         Arc2dBuilder {
             gizmos: self,
             position,
-            direction_angle,
-            arc_angle,
+            direction_angle: direction_angle.into(),
+            arc_angle: arc_angle.into(),
             radius,
             color,
             segments: None,
@@ -63,8 +63,8 @@ impl<'s> Gizmos<'s> {
 pub struct Arc2dBuilder<'a, 's> {
     gizmos: &'a mut Gizmos<'s>,
     position: Vec2,
-    direction_angle: Angle,
-    arc_angle: Angle,
+    direction_angle: Radians,
+    arc_angle: Radians,
     radius: f32,
     color: Color,
     segments: Option<usize>,
@@ -84,8 +84,7 @@ impl Drop for Arc2dBuilder<'_, '_> {
             Some(segments) => segments,
             // Do a linear interpolation between 1 and `DEFAULT_CIRCLE_SEGMENTS`
             // using the arc angle as scalar.
-            None => ((self.arc_angle.as_radians().abs() / TAU) * DEFAULT_CIRCLE_SEGMENTS as f32)
-                .ceil() as usize,
+            None => ((self.arc_angle.0 / TAU) * DEFAULT_CIRCLE_SEGMENTS as f32).ceil() as usize,
         };
 
         let positions = arc_inner(self.direction_angle, self.arc_angle, self.radius, segments)
@@ -95,8 +94,8 @@ impl Drop for Arc2dBuilder<'_, '_> {
 }
 
 fn arc_inner(
-    direction_angle: Angle,
-    arc_angle: Angle,
+    direction_angle: Radians,
+    arc_angle: Radians,
     radius: f32,
     segments: usize,
 ) -> impl Iterator<Item = Vec2> {
diff --git a/crates/bevy_gizmos/src/circles.rs b/crates/bevy_gizmos/src/circles.rs
index 57b43ca7bc9b8..98995dd26ef9f 100644
--- a/crates/bevy_gizmos/src/circles.rs
+++ b/crates/bevy_gizmos/src/circles.rs
@@ -4,7 +4,7 @@
 //! and assorted support items.
 
 use crate::prelude::Gizmos;
-use bevy_math::{Angle, Quat, Vec2, Vec3};
+use bevy_math::{Angle, Quat, Radians, Vec2, Vec3};
 use bevy_render::color::Color;
 use std::f32::consts::TAU;
 
@@ -12,7 +12,7 @@ pub(crate) const DEFAULT_CIRCLE_SEGMENTS: usize = 32;
 
 fn circle_inner(radius: f32, segments: usize) -> impl Iterator<Item = Vec2> {
     (0..segments + 1).map(move |i| {
-        let angle = Angle::radians(i as f32 * TAU / segments as f32);
+        let angle = Radians(i as f32 * TAU / segments as f32);
         Vec2::from(angle.sin_cos()) * radius
     })
 }
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 0ec8e134b05e2..0d8294692d1d7 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -7,7 +7,7 @@ use bevy_core_pipeline::prelude::Camera3dBundle;
 use bevy_ecs::{entity::Entity, world::World};
 use bevy_hierarchy::{BuildWorldChildren, WorldChildBuilder};
 use bevy_log::{error, warn};
-use bevy_math::{Angle, Mat4, Vec3};
+use bevy_math::{Mat4, Radians, Vec3};
 use bevy_pbr::{
     AlphaMode, DirectionalLight, DirectionalLightBundle, PbrBundle, PointLight, PointLightBundle,
     SpotLight, SpotLightBundle, StandardMaterial, MAX_JOINTS,
@@ -1101,8 +1101,8 @@ fn load_node(
                                 intensity: light.intensity() * std::f32::consts::PI * 4.0,
                                 range: light.range().unwrap_or(20.0),
                                 radius: light.range().unwrap_or(0.0),
-                                inner_angle: Angle::radians(inner_cone_angle),
-                                outer_angle: Angle::radians(outer_cone_angle),
+                                inner_angle: Radians(inner_cone_angle),
+                                outer_angle: Radians(outer_cone_angle),
                                 ..Default::default()
                             },
                             ..Default::default()
diff --git a/crates/bevy_math/src/angle.rs b/crates/bevy_math/src/angle.rs
deleted file mode 100644
index 2e6235b0829fd..0000000000000
--- a/crates/bevy_math/src/angle.rs
+++ /dev/null
@@ -1,260 +0,0 @@
-use std::{
-    fmt::Debug,
-    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign},
-};
-
-/// An angle in radians.
-///
-/// # Example
-///
-/// ```
-/// use std::f32::consts::PI;
-/// use bevy_math::Angle;
-///
-/// // Create angles from radians or degrees
-/// let alpha = Angle::radians(PI);
-/// let beta = Angle::degrees(180.0);
-/// assert_eq!(alpha, beta);
-///
-/// // Get float values
-/// assert_eq!(alpha.as_radians(), PI);
-/// assert_eq!(alpha.as_degrees(), 180.0);
-///
-/// // Use trigonometric operations
-/// assert_eq!(alpha.cos(), -1.0);
-///
-/// // Wrap 3pi to range [-2pi, 2pi) to get pi
-/// let gamma = 3.0 * alpha;
-/// let wrapped = gamma.wrap();
-///
-/// // Small threshold for floating point error
-/// assert!((wrapped - alpha).abs() < Angle::radians(0.000001));
-/// ```
-#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
-#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
-pub struct Angle(f32);
-
-impl Angle {
-    /// An angle of zero.
-    pub const ZERO: Self = Self(0.0);
-    /// The angle 2π in radians.
-    #[doc(alias = "TWO_PI")]
-    pub const TAU: Self = Self(std::f32::consts::TAU);
-    /// The angle π (pi) in radians.
-    pub const PI: Self = Self(std::f32::consts::PI);
-    /// The angle π/2 in radians.
-    #[doc(alias = "HALF_PI")]
-    pub const FRAC_PI_2: Self = Self(std::f32::consts::FRAC_PI_2);
-    /// The angle π/3 in radians.
-    pub const FRAC_PI_3: Self = Self(std::f32::consts::FRAC_PI_3);
-    /// The angle π/4 in radians.
-    pub const FRAC_PI_4: Self = Self(std::f32::consts::FRAC_PI_4);
-    /// The angle π/6 in radians.
-    pub const FRAC_PI_6: Self = Self(std::f32::consts::FRAC_PI_6);
-    /// The angle π/8 in radians.
-    pub const FRAC_PI_8: Self = Self(std::f32::consts::FRAC_PI_8);
-
-    /// Returns the sine of the angle in radians.
-    #[inline]
-    pub fn sin(self) -> f32 {
-        self.0.sin()
-    }
-
-    /// Returns the cosine of the angle in radians.
-    #[inline]
-    pub fn cos(self) -> f32 {
-        self.0.cos()
-    }
-
-    /// Returns the tangent of the angle in radians.
-    #[inline]
-    pub fn tan(self) -> f32 {
-        self.0.tan()
-    }
-
-    /// Returns the sine and cosine of the angle in radians.
-    #[inline]
-    pub fn sin_cos(self) -> (f32, f32) {
-        self.0.sin_cos()
-    }
-
-    /// Creates an [`Angle`] from radians.
-    #[inline]
-    pub const fn radians(radians: f32) -> Self {
-        Self(radians)
-    }
-
-    /// Creates an [`Angle`] from degrees.
-    #[inline]
-    pub fn degrees(degrees: f32) -> Self {
-        Self(degrees.to_radians())
-    }
-
-    /// Returns the angle in radians.
-    #[inline]
-    pub fn as_radians(self) -> f32 {
-        self.0
-    }
-
-    /// Returns the angle in degrees.
-    #[inline]
-    pub fn as_degrees(self) -> f32 {
-        self.0.to_degrees()
-    }
-
-    /// Returns the absolute angle.
-    #[inline]
-    pub fn abs(self) -> Self {
-        Self(self.0.abs())
-    }
-
-    /// Returns the minimum of the two angles, ignoring NaN.
-    #[inline]
-    pub fn min(self, other: Self) -> Self {
-        Self(self.0.min(other.0))
-    }
-
-    /// Returns the maximum of the two angles, ignoring NaN.
-    #[inline]
-    pub fn max(self, other: Self) -> Self {
-        Self(self.0.max(other.0))
-    }
-
-    /// Wraps the angle to be within the `[-2pi, 2pi)` range.
-    #[inline]
-    #[doc(alias = "normalize")]
-    pub fn wrap(self) -> Self {
-        Self(self.0 % std::f32::consts::TAU)
-    }
-
-    /// Returns the largest integer angle less than or equal to `self`.
-    #[inline]
-    pub fn floor(self) -> Self {
-        Self(self.0.floor())
-    }
-
-    /// Returns the smallest integer angle greater than or equal to `self`.
-    #[inline]
-    pub fn ceil(self) -> Self {
-        Self(self.0.ceil())
-    }
-
-    /// Returns the nearest integer to `self`. If a value is half-way
-    /// between two integers, round away from `0.0`.
-    #[inline]
-    pub fn round(self) -> Self {
-        Self(self.0.round())
-    }
-}
-
-impl Add for Angle {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Self(self.0 + rhs.0)
-    }
-}
-
-impl Sub for Angle {
-    type Output = Self;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        Self(self.0 - rhs.0)
-    }
-}
-
-impl Mul for Angle {
-    type Output = Self;
-
-    fn mul(self, rhs: Angle) -> Self::Output {
-        Self(self.0 * rhs.0)
-    }
-}
-
-impl Mul<f32> for Angle {
-    type Output = Self;
-
-    fn mul(self, rhs: f32) -> Self::Output {
-        Self(self.0 * rhs)
-    }
-}
-
-impl Mul<Angle> for f32 {
-    type Output = Angle;
-
-    fn mul(self, rhs: Angle) -> Self::Output {
-        Angle::radians(self * rhs.0)
-    }
-}
-
-impl Div for Angle {
-    type Output = Self;
-
-    fn div(self, rhs: Self) -> Self::Output {
-        Self(self.0 / rhs.0)
-    }
-}
-
-impl Div<f32> for Angle {
-    type Output = Self;
-
-    fn div(self, rhs: f32) -> Self::Output {
-        Self(self.0 / rhs)
-    }
-}
-
-impl Neg for Angle {
-    type Output = Self;
-
-    fn neg(self) -> Self::Output {
-        Self(-self.0)
-    }
-}
-
-impl AddAssign<Angle> for Angle {
-    fn add_assign(&mut self, rhs: Angle) {
-        self.0 += rhs.0;
-    }
-}
-
-impl SubAssign<Angle> for Angle {
-    fn sub_assign(&mut self, rhs: Angle) {
-        self.0 -= rhs.0;
-    }
-}
-
-impl MulAssign<Angle> for Angle {
-    fn mul_assign(&mut self, rhs: Angle) {
-        self.0 *= rhs.0;
-    }
-}
-
-impl DivAssign<Angle> for Angle {
-    fn div_assign(&mut self, rhs: Angle) {
-        self.0 /= rhs.0;
-    }
-}
-
-impl AddAssign<f32> for Angle {
-    fn add_assign(&mut self, rhs: f32) {
-        self.0 += rhs;
-    }
-}
-
-impl SubAssign<f32> for Angle {
-    fn sub_assign(&mut self, rhs: f32) {
-        self.0 -= rhs;
-    }
-}
-
-impl MulAssign<f32> for Angle {
-    fn mul_assign(&mut self, rhs: f32) {
-        self.0 *= rhs;
-    }
-}
-
-impl DivAssign<f32> for Angle {
-    fn div_assign(&mut self, rhs: f32) {
-        self.0 /= rhs;
-    }
-}
diff --git a/crates/bevy_math/src/angle/degrees.rs b/crates/bevy_math/src/angle/degrees.rs
new file mode 100644
index 0000000000000..87e54adcde1bf
--- /dev/null
+++ b/crates/bevy_math/src/angle/degrees.rs
@@ -0,0 +1,239 @@
+use std::{
+    fmt::Debug,
+    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign},
+};
+
+use crate::{Angle, Radians};
+
+/// An angle in degrees.
+///
+/// # Example
+///
+/// ```
+/// use std::f32::consts::PI;
+/// use bevy_math::{Angle, Degrees, Radians};
+///
+/// // Create angles from radians or degrees
+/// let alpha = Degrees(180.0);
+/// let beta = Degrees::from_radians(PI);
+/// assert_eq!(alpha, beta);
+/// assert_eq!(beta, Radians(PI));
+///
+/// // Add degrees and radians together (result is always radians)
+/// assert_eq!(Radians(PI) + Degrees(180.0), Radians(2.0 * PI));
+///
+/// // Get float values
+/// assert_eq!(alpha.0, 180.0);
+/// assert_eq!(alpha.to_radians().0, PI);
+///
+/// // Use trigonometric operations
+/// assert_eq!(alpha.cos(), -1.0);
+///
+/// // Normalize 540 degrees to range [0, 360) to get 180 degrees
+/// let gamma = 3.0 * alpha;
+/// let normalized = gamma.normalized();
+///
+/// // Small threshold for floating point error
+/// assert!((normalized - alpha).abs() < Degrees(0.000001));
+/// ```
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+pub struct Degrees(pub f32);
+
+impl Degrees {
+    /// Creates an angle in [`Degrees`] from radians.
+    #[inline]
+    pub fn from_radians(radians: f32) -> Self {
+        Self(radians.to_degrees())
+    }
+
+    /// Returns the angle in [`Radians`].
+    #[inline]
+    pub fn to_radians(self) -> Radians {
+        Radians::from_degrees(self.0)
+    }
+}
+
+impl Angle for Degrees {
+    const ZERO: Self = Self(0.0);
+    const EIGHTH: Self = Self(45.0);
+    const QUARTER: Self = Self(90.0);
+    const HALF: Self = Self(180.0);
+    const FULL: Self = Self(360.0);
+
+    #[inline]
+    fn new(angle: f32) -> Self {
+        Self(angle)
+    }
+
+    #[inline]
+    fn value(self) -> f32 {
+        self.0
+    }
+
+    #[inline]
+    fn sin(self) -> f32 {
+        self.to_radians().sin()
+    }
+
+    #[inline]
+    fn cos(self) -> f32 {
+        self.to_radians().cos()
+    }
+
+    #[inline]
+    fn tan(self) -> f32 {
+        self.to_radians().tan()
+    }
+
+    #[inline]
+    fn sin_cos(self) -> (f32, f32) {
+        self.to_radians().sin_cos()
+    }
+}
+
+impl From<Radians> for Degrees {
+    fn from(angle: Radians) -> Self {
+        angle.to_degrees()
+    }
+}
+
+impl Add for Degrees {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl Sub for Degrees {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Self(self.0 - rhs.0)
+    }
+}
+
+impl Mul for Degrees {
+    type Output = Self;
+
+    fn mul(self, rhs: Degrees) -> Self::Output {
+        Self(self.0 * rhs.0)
+    }
+}
+
+impl Mul<f32> for Degrees {
+    type Output = Self;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        Self(self.0 * rhs)
+    }
+}
+
+impl Mul<Degrees> for f32 {
+    type Output = Degrees;
+
+    fn mul(self, rhs: Degrees) -> Self::Output {
+        Degrees(self * rhs.0)
+    }
+}
+
+impl Div for Degrees {
+    type Output = Self;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        Self(self.0 / rhs.0)
+    }
+}
+
+impl Div<f32> for Degrees {
+    type Output = Self;
+
+    fn div(self, rhs: f32) -> Self::Output {
+        Self(self.0 / rhs)
+    }
+}
+
+impl Rem for Degrees {
+    type Output = Self;
+
+    fn rem(self, rhs: Self) -> Self::Output {
+        Self(self.0 % rhs.0)
+    }
+}
+
+impl Rem<f32> for Degrees {
+    type Output = Self;
+
+    fn rem(self, rhs: f32) -> Self::Output {
+        Self(self.0 % rhs)
+    }
+}
+
+impl Neg for Degrees {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        Self(-self.0)
+    }
+}
+
+impl AddAssign for Degrees {
+    fn add_assign(&mut self, rhs: Degrees) {
+        self.0 += rhs.0;
+    }
+}
+
+impl AddAssign<f32> for Degrees {
+    fn add_assign(&mut self, rhs: f32) {
+        self.0 += rhs;
+    }
+}
+
+impl SubAssign for Degrees {
+    fn sub_assign(&mut self, rhs: Degrees) {
+        self.0 -= rhs.0;
+    }
+}
+
+impl SubAssign<f32> for Degrees {
+    fn sub_assign(&mut self, rhs: f32) {
+        self.0 -= rhs;
+    }
+}
+
+impl MulAssign for Degrees {
+    fn mul_assign(&mut self, rhs: Degrees) {
+        self.0 *= rhs.0;
+    }
+}
+
+impl MulAssign<f32> for Degrees {
+    fn mul_assign(&mut self, rhs: f32) {
+        self.0 *= rhs;
+    }
+}
+
+impl DivAssign for Degrees {
+    fn div_assign(&mut self, rhs: Degrees) {
+        self.0 /= rhs.0;
+    }
+}
+
+impl DivAssign<f32> for Degrees {
+    fn div_assign(&mut self, rhs: f32) {
+        self.0 /= rhs;
+    }
+}
+
+impl RemAssign for Degrees {
+    fn rem_assign(&mut self, rhs: Degrees) {
+        self.0 %= rhs.0;
+    }
+}
+
+impl RemAssign<f32> for Degrees {
+    fn rem_assign(&mut self, rhs: f32) {
+        self.0 %= rhs;
+    }
+}
diff --git a/crates/bevy_math/src/angle/mod.rs b/crates/bevy_math/src/angle/mod.rs
new file mode 100644
index 0000000000000..c8e9e192add28
--- /dev/null
+++ b/crates/bevy_math/src/angle/mod.rs
@@ -0,0 +1,268 @@
+use std::ops::{
+    Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign,
+};
+
+mod degrees;
+mod radians;
+
+pub use degrees::Degrees;
+pub use radians::Radians;
+
+/// A trait for functionality and constants shared by the [`Degrees`] and [`Radians`] types.
+pub trait Angle:
+    Sized
+    + Clone
+    + Copy
+    + Add<Output = Self>
+    + Sub<Output = Self>
+    + Mul<Output = Self>
+    + Div<Output = Self>
+    + Rem<Output = Self>
+    + Neg<Output = Self>
+    + PartialEq
+    + PartialOrd
+{
+    /// An angle of zero.
+    const ZERO: Self;
+    /// A `45` degree angle. Equivalent to `π/4` radians.
+    const EIGHTH: Self;
+    /// A `90` degree angle (right angle). Equivalent to `π/2` radians.
+    #[doc(alias = "RIGHT_ANGLE")]
+    const QUARTER: Self;
+    /// A `180` degree angle (straight angle). Equivalent to `π` radians.
+    #[doc(alias = "STRAIGHT_ANGLE")]
+    const HALF: Self;
+    /// A `360` degree angle (perigon). Equivalent to `2π` radians.
+    #[doc(alias = "FULL_ANGLE")]
+    const FULL: Self;
+
+    /// Creates a new angle.
+    fn new(angle: f32) -> Self;
+
+    /// Returns the angle value contained within `self`.
+    fn value(self) -> f32;
+
+    /// Returns the sine of the angle.
+    fn sin(self) -> f32;
+
+    /// Returns the cosine of the angle.
+    fn cos(self) -> f32;
+
+    /// Returns the tangent of the angle.
+    fn tan(self) -> f32;
+
+    /// Returns the sine and cosine of the angle.
+    fn sin_cos(self) -> (f32, f32);
+
+    /// Returns the absolute angle.
+    fn abs(self) -> Self {
+        Self::new(self.value().abs())
+    }
+
+    /// Returns the minimum of the two angles, ignoring NaN.
+    fn min(self, other: Self) -> Self {
+        Self::new(self.value().min(other.value()))
+    }
+
+    /// Returns the maximum of the two angles, ignoring NaN.
+    fn max(self, other: Self) -> Self {
+        Self::new(self.value().max(other.value()))
+    }
+
+    /// Normalizes the angle to be within the range of `[0, 360)` degrees or `[0, 2π)` radians.
+    fn normalized(self) -> Self {
+        if self < Self::FULL && self > Self::ZERO {
+            self
+        } else {
+            let remainder = self % Self::FULL;
+            if remainder >= Self::ZERO {
+                remainder
+            } else {
+                remainder + Self::FULL
+            }
+        }
+    }
+
+    /// Returns the largest integer angle less than or equal to `self`.
+    #[inline]
+    fn floor(self) -> Self {
+        Self::new(self.value().floor())
+    }
+
+    /// Returns the smallest integer angle greater than or equal to `self`.
+    #[inline]
+    fn ceil(self) -> Self {
+        Self::new(self.value().ceil())
+    }
+
+    /// Returns the nearest integer to `self`. If a value is half-way
+    /// between two integers, round away from `0.0`.
+    #[inline]
+    fn round(self) -> Self {
+        Self::new(self.value().round())
+    }
+}
+
+impl PartialEq<Radians> for Degrees {
+    fn eq(&self, other: &Radians) -> bool {
+        *self == other.to_degrees()
+    }
+}
+
+impl PartialEq<Degrees> for Radians {
+    fn eq(&self, other: &Degrees) -> bool {
+        *self == other.to_radians()
+    }
+}
+
+impl PartialOrd<Radians> for Degrees {
+    fn partial_cmp(&self, other: &Radians) -> Option<std::cmp::Ordering> {
+        self.partial_cmp(&other.to_degrees())
+    }
+}
+
+impl PartialOrd<Degrees> for Radians {
+    fn partial_cmp(&self, other: &Degrees) -> Option<std::cmp::Ordering> {
+        self.partial_cmp(&other.to_radians())
+    }
+}
+
+impl Add<Radians> for Degrees {
+    type Output = Radians;
+
+    fn add(self, rhs: Radians) -> Self::Output {
+        self.to_radians() + rhs
+    }
+}
+
+impl Add<Degrees> for Radians {
+    type Output = Radians;
+
+    fn add(self, rhs: Degrees) -> Self::Output {
+        self + rhs.to_radians()
+    }
+}
+
+impl Sub<Radians> for Degrees {
+    type Output = Radians;
+
+    fn sub(self, rhs: Radians) -> Self::Output {
+        self.to_radians() - rhs
+    }
+}
+
+impl Sub<Degrees> for Radians {
+    type Output = Radians;
+
+    fn sub(self, rhs: Degrees) -> Self::Output {
+        self - rhs.to_radians()
+    }
+}
+
+impl Mul<Radians> for Degrees {
+    type Output = Radians;
+
+    fn mul(self, rhs: Radians) -> Self::Output {
+        self.to_radians() * rhs
+    }
+}
+
+impl Mul<Degrees> for Radians {
+    type Output = Radians;
+
+    fn mul(self, rhs: Degrees) -> Self::Output {
+        self * rhs.to_radians()
+    }
+}
+
+impl Div<Radians> for Degrees {
+    type Output = Radians;
+
+    fn div(self, rhs: Radians) -> Self::Output {
+        self.to_radians() / rhs
+    }
+}
+
+impl Div<Degrees> for Radians {
+    type Output = Radians;
+
+    fn div(self, rhs: Degrees) -> Self::Output {
+        self / rhs.to_radians()
+    }
+}
+
+impl Rem<Radians> for Degrees {
+    type Output = Radians;
+
+    fn rem(self, rhs: Radians) -> Self::Output {
+        self.to_radians() % rhs
+    }
+}
+
+impl Rem<Degrees> for Radians {
+    type Output = Radians;
+
+    fn rem(self, rhs: Degrees) -> Self::Output {
+        self % rhs.to_radians()
+    }
+}
+
+impl AddAssign<Radians> for Degrees {
+    fn add_assign(&mut self, rhs: Radians) {
+        *self += rhs.to_degrees();
+    }
+}
+
+impl AddAssign<Degrees> for Radians {
+    fn add_assign(&mut self, rhs: Degrees) {
+        *self += rhs.to_radians();
+    }
+}
+
+impl SubAssign<Radians> for Degrees {
+    fn sub_assign(&mut self, rhs: Radians) {
+        *self -= rhs.to_degrees();
+    }
+}
+
+impl SubAssign<Degrees> for Radians {
+    fn sub_assign(&mut self, rhs: Degrees) {
+        *self -= rhs.to_radians();
+    }
+}
+
+impl MulAssign<Radians> for Degrees {
+    fn mul_assign(&mut self, rhs: Radians) {
+        *self *= rhs.to_degrees();
+    }
+}
+
+impl MulAssign<Degrees> for Radians {
+    fn mul_assign(&mut self, rhs: Degrees) {
+        *self *= rhs.to_radians();
+    }
+}
+
+impl DivAssign<Radians> for Degrees {
+    fn div_assign(&mut self, rhs: Radians) {
+        *self /= rhs.to_degrees();
+    }
+}
+
+impl DivAssign<Degrees> for Radians {
+    fn div_assign(&mut self, rhs: Degrees) {
+        *self /= rhs.to_radians();
+    }
+}
+
+impl RemAssign<Radians> for Degrees {
+    fn rem_assign(&mut self, rhs: Radians) {
+        *self %= rhs.to_degrees();
+    }
+}
+
+impl RemAssign<Degrees> for Radians {
+    fn rem_assign(&mut self, rhs: Degrees) {
+        *self %= rhs.to_radians();
+    }
+}
diff --git a/crates/bevy_math/src/angle/radians.rs b/crates/bevy_math/src/angle/radians.rs
new file mode 100644
index 0000000000000..90b9d76db75b0
--- /dev/null
+++ b/crates/bevy_math/src/angle/radians.rs
@@ -0,0 +1,288 @@
+use std::{
+    fmt::Debug,
+    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign},
+};
+
+use crate::{Angle, Degrees};
+
+/// An angle in radians.
+///
+/// # Example
+///
+/// ```
+/// use std::f32::consts::PI;
+/// use bevy_math::{Angle, Degrees, Radians};
+///
+/// // Create angles from radians or degrees
+/// let alpha = Radians(PI);
+/// let beta = Radians::from_degrees(180.0);
+/// assert_eq!(alpha, beta);
+/// assert_eq!(beta, Degrees(180.0));
+///
+/// // Add degrees and radians together (result is always radians)
+/// assert_eq!(Radians(PI) + Degrees(180.0), Radians(2.0 * PI));
+///
+/// // Get float values
+/// assert_eq!(alpha.0, PI);
+/// assert_eq!(alpha.to_degrees().0, 180.0);
+///
+/// // Use trigonometric operations
+/// assert_eq!(alpha.cos(), -1.0);
+///
+/// // Normalize 3π to range [0, 2π) to get π
+/// let gamma = 3.0 * alpha;
+/// let normalized = gamma.normalized();
+///
+/// // Small threshold for floating point error
+/// assert!((normalized - alpha).abs() < Radians(0.000001));
+/// ```
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+pub struct Radians(pub f32);
+
+impl Radians {
+    /// The angle 2π. Equivalent to `Radians::FULL`.
+    #[doc(alias = "TWO_PI")]
+    pub const TAU: Self = Self(std::f32::consts::TAU);
+    /// The angle π (π). Equivalent to `Radians::HALF`.
+    pub const PI: Self = Self(std::f32::consts::PI);
+    /// The angle π/2. Equivalent to `Radians::QUARTER`.
+    #[doc(alias = "HALF_PI")]
+    pub const FRAC_PI_2: Self = Self(std::f32::consts::FRAC_PI_2);
+    /// The angle π/3.
+    pub const FRAC_PI_3: Self = Self(std::f32::consts::FRAC_PI_3);
+    /// The angle π/4. Equivalent to `Radians::EIGHTH`.
+    pub const FRAC_PI_4: Self = Self(std::f32::consts::FRAC_PI_4);
+    /// The angle π/6.
+    pub const FRAC_PI_6: Self = Self(std::f32::consts::FRAC_PI_6);
+    /// The angle π/8.
+    pub const FRAC_PI_8: Self = Self(std::f32::consts::FRAC_PI_8);
+
+    /// Creates an angle in [`Radians`] from degrees.
+    #[inline]
+    pub fn from_degrees(degrees: f32) -> Self {
+        Self(degrees.to_radians())
+    }
+
+    /// Returns the angle in [`Degrees`].
+    #[inline]
+    pub fn to_degrees(self) -> Degrees {
+        Degrees::from_radians(self.0)
+    }
+}
+
+impl Angle for Radians {
+    const ZERO: Self = Self(0.0);
+    const EIGHTH: Self = Self::FRAC_PI_4;
+    const QUARTER: Self = Self::FRAC_PI_2;
+    const HALF: Self = Self::PI;
+    const FULL: Self = Self::TAU;
+
+    #[inline]
+    fn new(angle: f32) -> Self {
+        Self(angle)
+    }
+
+    #[inline]
+    fn value(self) -> f32 {
+        self.0
+    }
+
+    #[inline]
+    fn sin(self) -> f32 {
+        self.0.sin()
+    }
+
+    #[inline]
+    fn cos(self) -> f32 {
+        self.0.cos()
+    }
+
+    #[inline]
+    fn tan(self) -> f32 {
+        self.0.tan()
+    }
+
+    #[inline]
+    fn sin_cos(self) -> (f32, f32) {
+        self.0.sin_cos()
+    }
+}
+
+impl From<Degrees> for Radians {
+    fn from(angle: Degrees) -> Self {
+        angle.to_radians()
+    }
+}
+
+impl Add for Radians {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl Add<f32> for Radians {
+    type Output = Self;
+
+    fn add(self, rhs: f32) -> Self::Output {
+        Self(self.0 + rhs)
+    }
+}
+
+impl Add<Radians> for f32 {
+    type Output = Radians;
+
+    fn add(self, rhs: Radians) -> Self::Output {
+        Radians(self + rhs.0)
+    }
+}
+
+impl Sub for Radians {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Self(self.0 - rhs.0)
+    }
+}
+
+impl Sub<f32> for Radians {
+    type Output = Self;
+
+    fn sub(self, rhs: f32) -> Self::Output {
+        Self(self.0 - rhs)
+    }
+}
+
+impl Sub<Radians> for f32 {
+    type Output = Radians;
+
+    fn sub(self, rhs: Radians) -> Self::Output {
+        Radians(self - rhs.0)
+    }
+}
+
+impl Mul for Radians {
+    type Output = Self;
+
+    fn mul(self, rhs: Radians) -> Self::Output {
+        Self(self.0 * rhs.0)
+    }
+}
+
+impl Mul<f32> for Radians {
+    type Output = Self;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        Self(self.0 * rhs)
+    }
+}
+
+impl Mul<Radians> for f32 {
+    type Output = Radians;
+
+    fn mul(self, rhs: Radians) -> Self::Output {
+        Radians(self * rhs.0)
+    }
+}
+
+impl Div for Radians {
+    type Output = Self;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        Self(self.0 / rhs.0)
+    }
+}
+
+impl Div<f32> for Radians {
+    type Output = Self;
+
+    fn div(self, rhs: f32) -> Self::Output {
+        Self(self.0 / rhs)
+    }
+}
+
+impl Rem for Radians {
+    type Output = Self;
+
+    fn rem(self, rhs: Self) -> Self::Output {
+        Self(self.0 % rhs.0)
+    }
+}
+
+impl Rem<f32> for Radians {
+    type Output = Self;
+
+    fn rem(self, rhs: f32) -> Self::Output {
+        Self(self.0 % rhs)
+    }
+}
+
+impl Neg for Radians {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output {
+        Self(-self.0)
+    }
+}
+
+impl AddAssign for Radians {
+    fn add_assign(&mut self, rhs: Radians) {
+        self.0 += rhs.0;
+    }
+}
+
+impl AddAssign<f32> for Radians {
+    fn add_assign(&mut self, rhs: f32) {
+        self.0 += rhs;
+    }
+}
+
+impl SubAssign for Radians {
+    fn sub_assign(&mut self, rhs: Radians) {
+        self.0 -= rhs.0;
+    }
+}
+
+impl SubAssign<f32> for Radians {
+    fn sub_assign(&mut self, rhs: f32) {
+        self.0 -= rhs;
+    }
+}
+
+impl MulAssign for Radians {
+    fn mul_assign(&mut self, rhs: Radians) {
+        self.0 *= rhs.0;
+    }
+}
+
+impl MulAssign<f32> for Radians {
+    fn mul_assign(&mut self, rhs: f32) {
+        self.0 *= rhs;
+    }
+}
+
+impl DivAssign for Radians {
+    fn div_assign(&mut self, rhs: Radians) {
+        self.0 /= rhs.0;
+    }
+}
+
+impl DivAssign<f32> for Radians {
+    fn div_assign(&mut self, rhs: f32) {
+        self.0 /= rhs;
+    }
+}
+
+impl RemAssign for Radians {
+    fn rem_assign(&mut self, rhs: Radians) {
+        self.0 %= rhs.0;
+    }
+}
+
+impl RemAssign<f32> for Radians {
+    fn rem_assign(&mut self, rhs: f32) {
+        self.0 %= rhs;
+    }
+}
diff --git a/crates/bevy_math/src/lib.rs b/crates/bevy_math/src/lib.rs
index f294d93331eec..f035abc3c02fc 100644
--- a/crates/bevy_math/src/lib.rs
+++ b/crates/bevy_math/src/lib.rs
@@ -15,7 +15,7 @@ mod ray;
 mod rects;
 
 pub use affine3::*;
-pub use angle::Angle;
+pub use angle::{Angle, Degrees, Radians};
 pub use aspect_ratio::AspectRatio;
 pub use ray::{Ray2d, Ray3d};
 pub use rects::*;
@@ -24,12 +24,13 @@ pub use rects::*;
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
+        angle::{Angle, Degrees, Radians},
         cubic_splines::{
             CubicBSpline, CubicBezier, CubicCardinalSpline, CubicGenerator, CubicHermite,
             CubicSegment,
         },
-        primitives, Angle, BVec2, BVec3, BVec4, EulerRot, IRect, IVec2, IVec3, IVec4, Mat2, Mat3,
-        Mat4, Quat, Ray2d, Ray3d, Rect, URect, UVec2, UVec3, UVec4, Vec2, Vec2Swizzles, Vec3,
+        primitives, BVec2, BVec3, BVec4, EulerRot, IRect, IVec2, IVec3, IVec4, Mat2, Mat3, Mat4,
+        Quat, Ray2d, Ray3d, Rect, URect, UVec2, UVec3, UVec4, Vec2, Vec2Swizzles, Vec3,
         Vec3Swizzles, Vec4, Vec4Swizzles,
     };
 }
diff --git a/crates/bevy_pbr/src/light.rs b/crates/bevy_pbr/src/light.rs
index f5b2c8d263649..f21ec10ee9d58 100644
--- a/crates/bevy_pbr/src/light.rs
+++ b/crates/bevy_pbr/src/light.rs
@@ -2,7 +2,8 @@ use std::collections::HashSet;
 
 use bevy_ecs::prelude::*;
 use bevy_math::{
-    Angle, AspectRatio, Mat4, UVec2, UVec3, Vec2, Vec3, Vec3A, Vec3Swizzles, Vec4, Vec4Swizzles,
+    Angle, AspectRatio, Mat4, Radians, UVec2, UVec3, Vec2, Vec3, Vec3A, Vec3Swizzles, Vec4,
+    Vec4Swizzles,
 };
 use bevy_reflect::prelude::*;
 use bevy_render::{
@@ -107,12 +108,12 @@ pub struct SpotLight {
     /// `outer_angle` should be < `PI / 2.0`.
     /// `PI / 2.0` defines a hemispherical spot light, but shadows become very blocky as the angle
     /// approaches this limit.
-    pub outer_angle: Angle,
+    pub outer_angle: Radians,
     /// Angle defining the distance from the spot light direction to the inner limit
     /// of the light's cone of effect.
     /// Light is attenuated from `inner_angle` to `outer_angle` to give a smooth falloff.
     /// `inner_angle` should be <= `outer_angle`
-    pub inner_angle: Angle,
+    pub inner_angle: Radians,
 }
 
 impl SpotLight {
@@ -131,8 +132,8 @@ impl Default for SpotLight {
             shadows_enabled: false,
             shadow_depth_bias: Self::DEFAULT_SHADOW_DEPTH_BIAS,
             shadow_normal_bias: Self::DEFAULT_SHADOW_NORMAL_BIAS,
-            inner_angle: Angle::ZERO,
-            outer_angle: Angle::FRAC_PI_4,
+            inner_angle: Radians::ZERO,
+            outer_angle: Radians::FRAC_PI_4,
         }
     }
 }
@@ -1155,7 +1156,7 @@ pub(crate) struct PointLightAssignmentData {
     transform: GlobalTransform,
     range: f32,
     shadows_enabled: bool,
-    spot_light_angle: Option<Angle>,
+    spot_light_angle: Option<Radians>,
     render_layers: RenderLayers,
 }
 
diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
index bc8d9f21f16b5..d871d5379b8bb 100644
--- a/crates/bevy_pbr/src/render/light.rs
+++ b/crates/bevy_pbr/src/render/light.rs
@@ -1,6 +1,6 @@
 use bevy_core_pipeline::core_3d::{Transparent3d, CORE_3D_DEPTH_FORMAT};
 use bevy_ecs::prelude::*;
-use bevy_math::{Angle, Mat4, UVec3, UVec4, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles};
+use bevy_math::{Angle, Mat4, Radians, UVec3, UVec4, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles};
 use bevy_render::{
     camera::Camera,
     color::Color,
@@ -35,7 +35,7 @@ pub struct ExtractedPointLight {
     shadows_enabled: bool,
     shadow_depth_bias: f32,
     shadow_normal_bias: f32,
-    spot_light_angles: Option<(Angle, Angle)>,
+    spot_light_angles: Option<(Radians, Radians)>,
 }
 
 #[derive(Component, Debug)]
@@ -635,9 +635,9 @@ pub(crate) fn spot_light_view_matrix(transform: &GlobalTransform) -> Mat4 {
     )
 }
 
-pub(crate) fn spot_light_projection_matrix(angle: Angle) -> Mat4 {
+pub(crate) fn spot_light_projection_matrix(angle: impl Into<Radians>) -> Mat4 {
     // spot light projection FOV is 2x the angle from spot light center to outer edge
-    Mat4::perspective_infinite_reverse_rh(angle.as_radians() * 2.0, 1.0, POINT_LIGHT_NEAR_Z)
+    Mat4::perspective_infinite_reverse_rh(angle.into().0 * 2.0, 1.0, POINT_LIGHT_NEAR_Z)
 }
 
 #[allow(clippy::too_many_arguments)]
diff --git a/crates/bevy_reflect/src/impls/angle.rs b/crates/bevy_reflect/src/impls/angle.rs
index 7011a47bb1eae..6820eca864d0b 100644
--- a/crates/bevy_reflect/src/impls/angle.rs
+++ b/crates/bevy_reflect/src/impls/angle.rs
@@ -2,7 +2,7 @@ use crate::prelude::ReflectDefault;
 use crate::{self as bevy_reflect, ReflectDeserialize, ReflectSerialize};
 use bevy_reflect_derive::impl_reflect_value;
 
-impl_reflect_value!(::bevy_math::Angle(
+impl_reflect_value!(::bevy_math::Radians(
     Debug,
     Default,
     PartialEq,
diff --git a/crates/bevy_transform/src/components/transform.rs b/crates/bevy_transform/src/components/transform.rs
index 043a45cfed71f..42ff19f60eea0 100644
--- a/crates/bevy_transform/src/components/transform.rs
+++ b/crates/bevy_transform/src/components/transform.rs
@@ -1,6 +1,6 @@
 use super::GlobalTransform;
 use bevy_ecs::{component::Component, reflect::ReflectComponent};
-use bevy_math::Angle;
+use bevy_math::Radians;
 use bevy_math::{Affine3A, Mat3, Mat4, Quat, Vec3};
 use bevy_reflect::prelude::*;
 use bevy_reflect::Reflect;
@@ -256,32 +256,32 @@ impl Transform {
     ///
     /// If this [`Transform`] has a parent, the `axis` is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_axis(&mut self, axis: Vec3, angle: Angle) {
-        self.rotate(Quat::from_axis_angle(axis, angle.as_radians()));
+    pub fn rotate_axis(&mut self, axis: Vec3, angle: impl Into<Radians>) {
+        self.rotate(Quat::from_axis_angle(axis, angle.into().0));
     }
 
     /// Rotates this [`Transform`] around the `X` axis by `angle` in the counterclockwise direction.
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_x(&mut self, angle: Angle) {
-        self.rotate(Quat::from_rotation_x(angle.as_radians()));
+    pub fn rotate_x(&mut self, angle: impl Into<Radians>) {
+        self.rotate(Quat::from_rotation_x(angle.into().0));
     }
 
     /// Rotates this [`Transform`] around the `Y` axis by `angle` in the counterclockwise direction.
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_y(&mut self, angle: Angle) {
-        self.rotate(Quat::from_rotation_y(angle.as_radians()));
+    pub fn rotate_y(&mut self, angle: impl Into<Radians>) {
+        self.rotate(Quat::from_rotation_y(angle.into().0));
     }
 
     /// Rotates this [`Transform`] around the `Z` axis by `angle` in the counterclockwise direction.
     ///
     /// If this [`Transform`] has a parent, the axis is relative to the rotation of the parent.
     #[inline]
-    pub fn rotate_z(&mut self, angle: Angle) {
-        self.rotate(Quat::from_rotation_z(angle.as_radians()));
+    pub fn rotate_z(&mut self, angle: impl Into<Radians>) {
+        self.rotate(Quat::from_rotation_z(angle.into().0));
     }
 
     /// Rotates this [`Transform`] by the given `rotation`.
@@ -294,26 +294,26 @@ impl Transform {
 
     /// Rotates this [`Transform`] around its local `axis` by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_axis(&mut self, axis: Vec3, angle: Angle) {
-        self.rotate_local(Quat::from_axis_angle(axis, angle.as_radians()));
+    pub fn rotate_local_axis(&mut self, axis: Vec3, angle: impl Into<Radians>) {
+        self.rotate_local(Quat::from_axis_angle(axis, angle.into().0));
     }
 
     /// Rotates this [`Transform`] around its local `X` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_x(&mut self, angle: Angle) {
-        self.rotate_local(Quat::from_rotation_x(angle.as_radians()));
+    pub fn rotate_local_x(&mut self, angle: impl Into<Radians>) {
+        self.rotate_local(Quat::from_rotation_x(angle.into().0));
     }
 
     /// Rotates this [`Transform`] around its local `Y` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_y(&mut self, angle: Angle) {
-        self.rotate_local(Quat::from_rotation_y(angle.as_radians()));
+    pub fn rotate_local_y(&mut self, angle: impl Into<Radians>) {
+        self.rotate_local(Quat::from_rotation_y(angle.into().0));
     }
 
     /// Rotates this [`Transform`] around its local `Z` axis by `angle` in the counterclockwise direction.
     #[inline]
-    pub fn rotate_local_z(&mut self, angle: Angle) {
-        self.rotate_local(Quat::from_rotation_z(angle.as_radians()));
+    pub fn rotate_local_z(&mut self, angle: impl Into<Radians>) {
+        self.rotate_local(Quat::from_rotation_z(angle.into().0));
     }
 
     /// Translates this [`Transform`] around a `point` in space.
diff --git a/examples/2d/2d_gizmos.rs b/examples/2d/2d_gizmos.rs
index 95a63b087cc6b..30228e1ef062c 100644
--- a/examples/2d/2d_gizmos.rs
+++ b/examples/2d/2d_gizmos.rs
@@ -54,8 +54,8 @@ fn system(mut gizmos: Gizmos, time: Res<Time>) {
     // 1 and 32, using the arc length as scalar.
     gizmos.arc_2d(
         Vec2::ZERO,
-        Angle::radians(sin / 10.),
-        Angle::radians(PI / 2.),
+        Radians(sin / 10.),
+        Radians(PI / 2.),
         350.,
         Color::ORANGE_RED,
     );
diff --git a/examples/2d/pixel_grid_snap.rs b/examples/2d/pixel_grid_snap.rs
index c8df698471c5c..d675a19b4c28f 100644
--- a/examples/2d/pixel_grid_snap.rs
+++ b/examples/2d/pixel_grid_snap.rs
@@ -156,7 +156,7 @@ fn setup_camera(mut commands: Commands, mut images: ResMut<Assets<Image>>) {
 fn rotate(time: Res<Time>, mut transforms: Query<&mut Transform, With<Rotate>>) {
     for mut transform in &mut transforms {
         let dt = time.delta_seconds();
-        transform.rotate_z(Angle::radians(dt));
+        transform.rotate_z(Radians(dt));
     }
 }
 
diff --git a/examples/2d/rotation.rs b/examples/2d/rotation.rs
index dde6149c86699..31db43c98d6e1 100644
--- a/examples/2d/rotation.rs
+++ b/examples/2d/rotation.rs
@@ -138,7 +138,7 @@ fn player_movement_system(
     }
 
     // update the ship rotation around the Z axis (perpendicular to the 2D plane of the screen)
-    transform.rotate_z(Angle::radians(
+    transform.rotate_z(Radians(
         rotation_factor * ship.rotation_speed * time.delta_seconds(),
     ));
 
@@ -244,12 +244,11 @@ fn rotate_to_player_system(
 
         // limit rotation so we don't overshoot the target. We need to convert our dot product to
         // an angle here so we can get an angle of rotation to clamp against.
-        let max_angle = Angle::radians(forward_dot_player.clamp(-1.0, 1.0).acos());
+        let max_angle = Radians(forward_dot_player.clamp(-1.0, 1.0).acos());
 
         // calculate angle of rotation with limit
         let rotation_angle =
-            Angle::radians(rotation_sign * (config.rotation_speed * time.delta_seconds()))
-                .min(max_angle);
+            Radians(rotation_sign * (config.rotation_speed * time.delta_seconds())).min(max_angle);
 
         // rotate the enemy to face the player
         enemy_transform.rotate_z(rotation_angle);
diff --git a/examples/3d/3d_shapes.rs b/examples/3d/3d_shapes.rs
index 60db9e41febef..160541ddfe13e 100644
--- a/examples/3d/3d_shapes.rs
+++ b/examples/3d/3d_shapes.rs
@@ -88,7 +88,7 @@ fn setup(
 
 fn rotate(mut query: Query<&mut Transform, With<Shape>>, time: Res<Time>) {
     for mut transform in &mut query {
-        transform.rotate_y(Angle::radians(time.delta_seconds() / 2.));
+        transform.rotate_y(Radians(time.delta_seconds() / 2.));
     }
 }
 
diff --git a/examples/3d/deferred_rendering.rs b/examples/3d/deferred_rendering.rs
index 921eb52c026ff..aec9a86d2c678 100644
--- a/examples/3d/deferred_rendering.rs
+++ b/examples/3d/deferred_rendering.rs
@@ -240,7 +240,7 @@ fn animate_light_direction(
         return;
     }
     for mut transform in &mut query {
-        transform.rotate_y(Angle::radians(time.delta_seconds() * PI / 5.0));
+        transform.rotate_y(Radians(time.delta_seconds() * PI / 5.0));
     }
 }
 
@@ -283,7 +283,7 @@ fn setup_parallax(
             ..default()
         },
         Spin {
-            speed: Angle::radians(0.3),
+            speed: Radians(0.3),
         },
     ));
 }
@@ -311,7 +311,7 @@ fn update_normal(
 
 #[derive(Component)]
 struct Spin {
-    speed: Angle,
+    speed: Radians,
 }
 
 fn spin(time: Res<Time>, mut query: Query<(&mut Transform, &Spin)>, pause: Res<Pause>) {
diff --git a/examples/3d/generate_custom_mesh.rs b/examples/3d/generate_custom_mesh.rs
index 5d5ae714a5bab..a8ded2ed028cc 100644
--- a/examples/3d/generate_custom_mesh.rs
+++ b/examples/3d/generate_custom_mesh.rs
@@ -98,17 +98,17 @@ fn input_handler(
     }
     if keyboard_input.pressed(KeyCode::KeyX) {
         for mut transform in &mut query {
-            transform.rotate_x(Angle::radians(time.delta_seconds() / 1.2));
+            transform.rotate_x(Radians(time.delta_seconds() / 1.2));
         }
     }
     if keyboard_input.pressed(KeyCode::KeyY) {
         for mut transform in &mut query {
-            transform.rotate_y(Angle::radians(time.delta_seconds() / 1.2));
+            transform.rotate_y(Radians(time.delta_seconds() / 1.2));
         }
     }
     if keyboard_input.pressed(KeyCode::KeyZ) {
         for mut transform in &mut query {
-            transform.rotate_z(Angle::radians(time.delta_seconds() / 1.2));
+            transform.rotate_z(Radians(time.delta_seconds() / 1.2));
         }
     }
     if keyboard_input.pressed(KeyCode::KeyR) {
diff --git a/examples/3d/lighting.rs b/examples/3d/lighting.rs
index a6e6cc4d6a594..221c4b4c98a45 100644
--- a/examples/3d/lighting.rs
+++ b/examples/3d/lighting.rs
@@ -36,7 +36,7 @@ fn setup(
 
     // left wall
     let mut transform = Transform::from_xyz(2.5, 2.5, 0.0);
-    transform.rotate_z(Angle::FRAC_PI_2);
+    transform.rotate_z(Radians::FRAC_PI_2);
     commands.spawn(PbrBundle {
         mesh: meshes.add(Mesh::from(shape::Box::new(5.0, 0.15, 5.0))),
         transform,
@@ -49,7 +49,7 @@ fn setup(
     });
     // back (right) wall
     let mut transform = Transform::from_xyz(0.0, 2.5, -2.5);
-    transform.rotate_x(Angle::FRAC_PI_2);
+    transform.rotate_x(Radians::FRAC_PI_2);
     commands.spawn(PbrBundle {
         mesh: meshes.add(Mesh::from(shape::Box::new(5.0, 0.15, 5.0))),
         transform,
@@ -63,7 +63,7 @@ fn setup(
 
     // Bevy logo to demonstrate alpha mask shadows
     let mut transform = Transform::from_xyz(-2.2, 0.5, 1.0);
-    transform.rotate_y(Angle::FRAC_PI_8);
+    transform.rotate_y(Radians::FRAC_PI_8);
     commands.spawn((
         PbrBundle {
             mesh: meshes.add(Mesh::from(shape::Quad::new(Vec2::new(2.0, 0.5)))),
@@ -153,8 +153,8 @@ fn setup(
                 intensity: 1600.0, // lumens - roughly a 100W non-halogen incandescent bulb
                 color: Color::GREEN,
                 shadows_enabled: true,
-                inner_angle: Angle::radians(0.6),
-                outer_angle: Angle::radians(0.8),
+                inner_angle: Radians(0.6),
+                outer_angle: Radians(0.8),
                 ..default()
             },
             ..default()
@@ -256,7 +256,7 @@ fn animate_light_direction(
     mut query: Query<&mut Transform, With<DirectionalLight>>,
 ) {
     for mut transform in &mut query {
-        transform.rotate_y(Angle::radians(time.delta_seconds() * 0.5));
+        transform.rotate_y(Radians(time.delta_seconds() * 0.5));
     }
 }
 
diff --git a/examples/3d/parallax_mapping.rs b/examples/3d/parallax_mapping.rs
index 55e8d6d4a9343..df002e2bb3156 100644
--- a/examples/3d/parallax_mapping.rs
+++ b/examples/3d/parallax_mapping.rs
@@ -27,7 +27,7 @@ fn main() {
 
 #[derive(Component)]
 struct Spin {
-    speed: Angle,
+    speed: Radians,
 }
 
 /// The camera, used to move camera on click.
@@ -292,7 +292,7 @@ fn setup(
             ..default()
         },
         Spin {
-            speed: Angle::radians(0.3),
+            speed: Radians(0.3),
         },
     ));
 
@@ -311,7 +311,7 @@ fn setup(
                 ..default()
             },
             Spin {
-                speed: Angle::radians(-0.1),
+                speed: Radians(-0.1),
             },
         )
     };
diff --git a/examples/3d/parenting.rs b/examples/3d/parenting.rs
index 4ec6c6187c256..79359d2da2e07 100644
--- a/examples/3d/parenting.rs
+++ b/examples/3d/parenting.rs
@@ -18,7 +18,7 @@ struct Rotator;
 /// rotates the parent, which will result in the child also rotating
 fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotator>>) {
     for mut transform in &mut query {
-        transform.rotate_x(Angle::radians(3.0 * time.delta_seconds()));
+        transform.rotate_x(Radians(3.0 * time.delta_seconds()));
     }
 }
 
diff --git a/examples/3d/render_to_texture.rs b/examples/3d/render_to_texture.rs
index 788e1b2e73373..39a5a18c173c7 100644
--- a/examples/3d/render_to_texture.rs
+++ b/examples/3d/render_to_texture.rs
@@ -150,15 +150,15 @@ fn setup(
 /// Rotates the inner cube (first pass)
 fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<FirstPassCube>>) {
     for mut transform in &mut query {
-        transform.rotate_x(Angle::radians(1.5 * time.delta_seconds()));
-        transform.rotate_z(Angle::radians(1.3 * time.delta_seconds()));
+        transform.rotate_x(Radians(1.5 * time.delta_seconds()));
+        transform.rotate_z(Radians(1.3 * time.delta_seconds()));
     }
 }
 
 /// Rotates the outer cube (main pass)
 fn cube_rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<MainPassCube>>) {
     for mut transform in &mut query {
-        transform.rotate_x(Angle::radians(1.0 * time.delta_seconds()));
-        transform.rotate_y(Angle::radians(0.7 * time.delta_seconds()));
+        transform.rotate_x(Radians(1.0 * time.delta_seconds()));
+        transform.rotate_y(Radians(0.7 * time.delta_seconds()));
     }
 }
diff --git a/examples/3d/skybox.rs b/examples/3d/skybox.rs
index a40aef0da9b4e..3398f484883e5 100644
--- a/examples/3d/skybox.rs
+++ b/examples/3d/skybox.rs
@@ -166,7 +166,7 @@ fn animate_light_direction(
     mut query: Query<&mut Transform, With<DirectionalLight>>,
 ) {
     for mut transform in &mut query {
-        transform.rotate_y(Angle::radians(time.delta_seconds() * 0.5));
+        transform.rotate_y(Radians(time.delta_seconds() * 0.5));
     }
 }
 
diff --git a/examples/3d/spotlight.rs b/examples/3d/spotlight.rs
index bcde184792a85..1a5fa00734805 100644
--- a/examples/3d/spotlight.rs
+++ b/examples/3d/spotlight.rs
@@ -90,8 +90,8 @@ fn setup(
                         intensity: 200.0, // lumens
                         color: Color::WHITE,
                         shadows_enabled: true,
-                        inner_angle: Angle::FRAC_PI_4 * 0.85,
-                        outer_angle: Angle::FRAC_PI_4,
+                        inner_angle: Radians::FRAC_PI_4 * 0.85,
+                        outer_angle: Radians::FRAC_PI_4,
                         ..default()
                     },
                     ..default()
@@ -134,8 +134,7 @@ fn light_sway(time: Res<Time>, mut query: Query<(&mut Transform, &mut SpotLight)
             (time.elapsed_seconds() * 3.0).sin() * 0.5,
             0.0,
         );
-        let angle =
-            Angle::radians(((time.elapsed_seconds() * 1.2).sin() + 1.0) * (FRAC_PI_4 - 0.1));
+        let angle = Radians(((time.elapsed_seconds() * 1.2).sin() + 1.0) * (FRAC_PI_4 - 0.1));
         angles.inner_angle = angle * 0.8;
         angles.outer_angle = angle;
     }
diff --git a/examples/ecs/hierarchy.rs b/examples/ecs/hierarchy.rs
index e0ea34a8544a7..79fdb744b36a2 100644
--- a/examples/ecs/hierarchy.rs
+++ b/examples/ecs/hierarchy.rs
@@ -66,14 +66,14 @@ fn rotate(
 ) {
     for (parent, children) in &mut parents_query {
         if let Ok(mut transform) = transform_query.get_mut(parent) {
-            transform.rotate_z(Angle::radians(-PI / 2. * time.delta_seconds()));
+            transform.rotate_z(Radians(-PI / 2. * time.delta_seconds()));
         }
 
         // To iterate through the entities children, just treat the Children component as a Vec
         // Alternatively, you could query entities that have a Parent component
         for child in children {
             if let Ok(mut transform) = transform_query.get_mut(*child) {
-                transform.rotate_z(Angle::radians(PI * time.delta_seconds()));
+                transform.rotate_z(Radians(PI * time.delta_seconds()));
             }
         }
 
diff --git a/examples/games/alien_cake_addict.rs b/examples/games/alien_cake_addict.rs
index d803a8c387b1c..dd51a0f4aabc7 100644
--- a/examples/games/alien_cake_addict.rs
+++ b/examples/games/alien_cake_addict.rs
@@ -360,7 +360,7 @@ fn spawn_bonus(
 fn rotate_bonus(game: Res<Game>, time: Res<Time>, mut transforms: Query<&mut Transform>) {
     if let Some(entity) = game.bonus.entity {
         if let Ok(mut cake_transform) = transforms.get_mut(entity) {
-            cake_transform.rotate_y(Angle::radians(time.delta_seconds()));
+            cake_transform.rotate_y(Radians(time.delta_seconds()));
             cake_transform.scale =
                 Vec3::splat(1.0 + (game.score as f32 / 10.0 * time.elapsed_seconds().sin()).abs());
         }
diff --git a/examples/games/contributors.rs b/examples/games/contributors.rs
index 0339fbd008f38..155bd8c328cac 100644
--- a/examples/games/contributors.rs
+++ b/examples/games/contributors.rs
@@ -64,7 +64,7 @@ struct Contributor {
 #[derive(Component)]
 struct Velocity {
     translation: Vec3,
-    rotation: Angle,
+    rotation: Radians,
 }
 
 const GRAVITY: f32 = 9.821 * 100.0;
@@ -115,7 +115,7 @@ fn setup_contributor_selection(mut commands: Commands, asset_server: Res<AssetSe
                 Contributor { name, hue },
                 Velocity {
                     translation: velocity,
-                    rotation: Angle::radians(-dir * 5.0),
+                    rotation: Radians(-dir * 5.0),
                 },
                 SpriteBundle {
                     sprite: Sprite {
diff --git a/examples/shader/post_processing.rs b/examples/shader/post_processing.rs
index 820f3a95a22af..96939d99edcc1 100644
--- a/examples/shader/post_processing.rs
+++ b/examples/shader/post_processing.rs
@@ -342,8 +342,8 @@ struct Rotates;
 /// Rotates any entity around the x and y axis
 fn rotate(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
     for mut transform in &mut query {
-        transform.rotate_x(Angle::radians(0.55 * time.delta_seconds()));
-        transform.rotate_z(Angle::radians(0.15 * time.delta_seconds()));
+        transform.rotate_x(Radians(0.55 * time.delta_seconds()));
+        transform.rotate_z(Radians(0.15 * time.delta_seconds()));
     }
 }
 
diff --git a/examples/stress_tests/many_cubes.rs b/examples/stress_tests/many_cubes.rs
index 82c2a5baa2611..d6886196f69af 100644
--- a/examples/stress_tests/many_cubes.rs
+++ b/examples/stress_tests/many_cubes.rs
@@ -267,7 +267,7 @@ fn move_camera(
     mut camera_query: Query<&mut Transform, With<Camera>>,
 ) {
     let mut camera_transform = camera_query.single_mut();
-    let delta = Angle::radians(
+    let delta = Radians(
         0.15 * if args.benchmark {
             1.0 / 60.0
         } else {
diff --git a/examples/stress_tests/many_foxes.rs b/examples/stress_tests/many_foxes.rs
index 64d01acaf0b5a..d6f2c6eb77c3a 100644
--- a/examples/stress_tests/many_foxes.rs
+++ b/examples/stress_tests/many_foxes.rs
@@ -147,7 +147,7 @@ fn setup(
 
         let circumference = PI * 2. * radius;
         let foxes_in_ring = ((circumference / FOX_SPACING) as usize).min(foxes_remaining);
-        let fox_spacing_angle = Angle::radians(circumference / (foxes_in_ring as f32 * radius));
+        let fox_spacing_angle = Radians(circumference / (foxes_in_ring as f32 * radius));
 
         for fox_i in 0..foxes_in_ring {
             let fox_angle = fox_i as f32 * fox_spacing_angle;
@@ -159,9 +159,7 @@ fn setup(
                     scene: fox_handle.clone(),
                     transform: Transform::from_xyz(x, 0.0, z)
                         .with_scale(Vec3::splat(0.01))
-                        .with_rotation(
-                            base_rotation * Quat::from_rotation_y(-fox_angle.as_radians()),
-                        ),
+                        .with_rotation(base_rotation * Quat::from_rotation_y(-fox_angle.0)),
                     ..default()
                 });
             });
@@ -244,7 +242,7 @@ fn update_fox_rings(
 
     let dt = time.delta_seconds();
     for (ring, rotation_direction, mut transform) in &mut rings {
-        let angular_velocity = Angle::radians(foxes.speed / ring.radius);
+        let angular_velocity = Radians(foxes.speed / ring.radius);
         transform.rotate_y(rotation_direction.sign() * angular_velocity * dt);
     }
 }
diff --git a/examples/stress_tests/many_gizmos.rs b/examples/stress_tests/many_gizmos.rs
index 034cd6a34ba00..a2797eb4aef8f 100644
--- a/examples/stress_tests/many_gizmos.rs
+++ b/examples/stress_tests/many_gizmos.rs
@@ -61,7 +61,7 @@ fn system(config: Res<Config>, time: Res<Time>, mut draw: Gizmos) {
         }
     } else {
         for i in 0..(config.line_count / SYSTEM_COUNT) {
-            let angle = Angle::radians(i as f32 / (config.line_count / SYSTEM_COUNT) as f32 * TAU);
+            let angle = Radians(i as f32 / (config.line_count / SYSTEM_COUNT) as f32 * TAU);
 
             let vector = Vec2::from(angle.sin_cos()).extend(time.elapsed_seconds().sin());
             let start_color = Color::rgb(vector.x, vector.z, 0.5);
diff --git a/examples/stress_tests/many_lights.rs b/examples/stress_tests/many_lights.rs
index 61f860c4edd6a..024a22c85217c 100644
--- a/examples/stress_tests/many_lights.rs
+++ b/examples/stress_tests/many_lights.rs
@@ -135,7 +135,7 @@ fn spherical_polar_to_cartesian(p: DVec2) -> DVec3 {
 // System for rotating the camera
 fn move_camera(time: Res<Time>, mut camera_query: Query<&mut Transform, With<Camera>>) {
     let mut camera_transform = camera_query.single_mut();
-    let delta = Angle::radians(time.delta_seconds() * 0.15);
+    let delta = Radians(time.delta_seconds() * 0.15);
     camera_transform.rotate_z(delta);
     camera_transform.rotate_x(delta);
 }
diff --git a/examples/stress_tests/many_sprites.rs b/examples/stress_tests/many_sprites.rs
index fc6fb813edc3e..3304ad7cf86d4 100644
--- a/examples/stress_tests/many_sprites.rs
+++ b/examples/stress_tests/many_sprites.rs
@@ -101,7 +101,7 @@ fn setup(mut commands: Commands, assets: Res<AssetServer>, color_tint: Res<Color
 // System for rotating and translating the camera
 fn move_camera(time: Res<Time>, mut camera_query: Query<&mut Transform, With<Camera>>) {
     let mut camera_transform = camera_query.single_mut();
-    camera_transform.rotate_z(Angle::radians(time.delta_seconds() * 0.5));
+    camera_transform.rotate_z(Radians(time.delta_seconds() * 0.5));
     *camera_transform = *camera_transform
         * Transform::from_translation(Vec3::X * CAMERA_SPEED * time.delta_seconds());
 }
diff --git a/examples/stress_tests/transform_hierarchy.rs b/examples/stress_tests/transform_hierarchy.rs
index 16f477cfd9e23..5901182eb087f 100644
--- a/examples/stress_tests/transform_hierarchy.rs
+++ b/examples/stress_tests/transform_hierarchy.rs
@@ -19,7 +19,7 @@
 //! | `humanoids_mixed`    | 2000 active and 2000 inactive humanoid rigs.                      |
 
 use bevy::prelude::*;
-use bevy_internal::math::Angle;
+use bevy_internal::math::Radians;
 use rand::Rng;
 
 /// pre-defined test configurations with name
@@ -248,12 +248,12 @@ struct UpdateValue(f32);
 fn update(time: Res<Time>, mut query: Query<(&mut Transform, &mut UpdateValue)>) {
     for (mut t, mut u) in &mut query {
         u.0 += time.delta_seconds() * 0.1;
-        set_translation(&mut t.translation, Angle::radians(u.0));
+        set_translation(&mut t.translation, Radians(u.0));
     }
 }
 
 /// set translation based on the angle `a`
-fn set_translation(translation: &mut Vec3, a: Angle) {
+fn set_translation(translation: &mut Vec3, a: Radians) {
     translation.x = a.cos() * 32.0;
     translation.y = a.sin() * 32.0;
 }
@@ -410,7 +410,7 @@ fn spawn_tree(
                 let mut translation = Vec3::ZERO;
                 // use the same placement fn as the `update` system
                 // this way the entities won't be all at (0, 0, 0) when they don't have an `Update` component
-                set_translation(&mut translation, Angle::radians(sep));
+                set_translation(&mut translation, Radians(sep));
                 Transform::from_translation(translation)
             };
 
diff --git a/examples/tools/gamepad_viewer.rs b/examples/tools/gamepad_viewer.rs
index 6f1ca61a217f7..e3fd08b5d6823 100644
--- a/examples/tools/gamepad_viewer.rs
+++ b/examples/tools/gamepad_viewer.rs
@@ -7,7 +7,7 @@ use bevy::{
     prelude::*,
     sprite::{Anchor, MaterialMesh2dBundle, Mesh2dHandle},
 };
-use bevy_internal::math::Angle;
+use bevy_internal::math::Radians;
 
 const BUTTON_RADIUS: f32 = 25.;
 const BUTTON_CLUSTER_RADIUS: f32 = 50.;
@@ -106,8 +106,8 @@ impl GamepadButtonBundle {
         }
     }
 
-    pub fn with_rotation(mut self, angle: Angle) -> Self {
-        self.mesh_bundle.transform.rotation = Quat::from_rotation_z(angle.as_radians());
+    pub fn with_rotation(mut self, angle: impl Into<Radians>) -> Self {
+        self.mesh_bundle.transform.rotation = Quat::from_rotation_z(angle.into().0);
         self
     }
 }
@@ -215,7 +215,7 @@ fn setup(mut commands: Commands, meshes: Res<ButtonMeshes>, materials: Res<Butto
                     0.,
                     -BUTTON_CLUSTER_RADIUS,
                 )
-                .with_rotation(Angle::PI),
+                .with_rotation(Radians::PI),
             );
             parent.spawn(
                 GamepadButtonBundle::new(
@@ -225,7 +225,7 @@ fn setup(mut commands: Commands, meshes: Res<ButtonMeshes>, materials: Res<Butto
                     -BUTTON_CLUSTER_RADIUS,
                     0.,
                 )
-                .with_rotation(Angle::FRAC_PI_2),
+                .with_rotation(Radians::FRAC_PI_2),
             );
             parent.spawn(
                 GamepadButtonBundle::new(
@@ -235,7 +235,7 @@ fn setup(mut commands: Commands, meshes: Res<ButtonMeshes>, materials: Res<Butto
                     BUTTON_CLUSTER_RADIUS,
                     0.,
                 )
-                .with_rotation(-Angle::FRAC_PI_2),
+                .with_rotation(-Radians::FRAC_PI_2),
             );
         });
 
diff --git a/examples/transforms/3d_rotation.rs b/examples/transforms/3d_rotation.rs
index acf421bc6b27d..b4a4e73cb76b8 100644
--- a/examples/transforms/3d_rotation.rs
+++ b/examples/transforms/3d_rotation.rs
@@ -7,7 +7,7 @@ use std::f32::consts::TAU;
 // Define a component to designate a rotation speed to an entity.
 #[derive(Component)]
 struct Rotatable {
-    speed: Angle,
+    speed: Radians,
 }
 
 fn main() {
@@ -32,7 +32,7 @@ fn setup(
             ..default()
         },
         Rotatable {
-            speed: Angle::radians(0.3),
+            speed: Radians(0.3),
         },
     ));
 
diff --git a/examples/window/low_power.rs b/examples/window/low_power.rs
index 91ca29c704af5..4a4194d9a8886 100644
--- a/examples/window/low_power.rs
+++ b/examples/window/low_power.rs
@@ -117,8 +117,8 @@ pub(crate) mod test_setup {
         mut cube_transform: Query<&mut Transform, With<Rotator>>,
     ) {
         for mut transform in &mut cube_transform {
-            transform.rotate_x(Angle::radians(time.delta_seconds()));
-            transform.rotate_local_y(Angle::radians(time.delta_seconds()));
+            transform.rotate_x(Radians(time.delta_seconds()));
+            transform.rotate_local_y(Radians(time.delta_seconds()));
         }
     }
 

From 18633a49827b7cace06116474b77647db535f5fd Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 18:19:05 +0200
Subject: [PATCH 08/21] Add methods for math ops with inferred output to
 `Angle` trait

---
 crates/bevy_math/src/angle/mod.rs | 44 +++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/crates/bevy_math/src/angle/mod.rs b/crates/bevy_math/src/angle/mod.rs
index c8e9e192add28..0c0bad67dbeb3 100644
--- a/crates/bevy_math/src/angle/mod.rs
+++ b/crates/bevy_math/src/angle/mod.rs
@@ -55,21 +55,25 @@ pub trait Angle:
     fn sin_cos(self) -> (f32, f32);
 
     /// Returns the absolute angle.
+    #[inline]
     fn abs(self) -> Self {
         Self::new(self.value().abs())
     }
 
     /// Returns the minimum of the two angles, ignoring NaN.
+    #[inline]
     fn min(self, other: Self) -> Self {
         Self::new(self.value().min(other.value()))
     }
 
     /// Returns the maximum of the two angles, ignoring NaN.
+    #[inline]
     fn max(self, other: Self) -> Self {
         Self::new(self.value().max(other.value()))
     }
 
     /// Normalizes the angle to be within the range of `[0, 360)` degrees or `[0, 2π)` radians.
+    #[inline]
     fn normalized(self) -> Self {
         if self < Self::FULL && self > Self::ZERO {
             self
@@ -101,6 +105,46 @@ pub trait Angle:
     fn round(self) -> Self {
         Self::new(self.value().round())
     }
+
+    /// Adds the given `angle` to `self`, returning the inferred type of angle.
+    fn add_angle<T: Angle, Output: Angle>(self, angle: T) -> Output
+    where
+        Output: From<Self> + From<T>,
+    {
+        Output::from(self) + Output::from(angle)
+    }
+
+    /// Subtracts the given `angle` from `self`, returning the inferred type of angle.
+    fn sub_angle<T: Angle, Output: Angle>(self, angle: T) -> Output
+    where
+        Output: From<Self> + From<T>,
+    {
+        Output::from(self) - Output::from(angle)
+    }
+
+    /// Multiplies `self` by the given `angle`, returning the inferred type of angle.
+    fn mul_angle<T: Angle, Output: Angle>(self, angle: T) -> Output
+    where
+        Output: From<Self> + From<T>,
+    {
+        Output::from(self) * Output::from(angle)
+    }
+
+    /// Divides `self` by the given `angle`, returning the inferred type of angle.
+    fn div_angle<T: Angle, Output: Angle>(self, angle: T) -> Output
+    where
+        Output: From<Self> + From<T>,
+    {
+        Output::from(self) + Output::from(angle)
+    }
+
+    /// Computes the remainder of `self` divided by the given `angle`, returning the inferred type of angle.
+    fn rem_angle<T: Angle, Output: Angle>(self, angle: T) -> Output
+    where
+        Output: From<Self> + From<T>,
+    {
+        Output::from(self) % Output::from(angle)
+    }
 }
 
 impl PartialEq<Radians> for Degrees {

From 4ac6f5ca4bfe5e11f094ec6d62fb3dd557747815 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 19:57:01 +0200
Subject: [PATCH 09/21] Remove `Reflect` from angle types for now

---
 crates/bevy_gltf/src/loader.rs         |  6 +++---
 crates/bevy_pbr/src/light.rs           | 13 +++++++------
 crates/bevy_pbr/src/render/light.rs    |  5 ++++-
 crates/bevy_reflect/src/impls/angle.rs | 11 -----------
 crates/bevy_reflect/src/lib.rs         |  1 -
 5 files changed, 14 insertions(+), 22 deletions(-)
 delete mode 100644 crates/bevy_reflect/src/impls/angle.rs

diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 0d8294692d1d7..4d1d3e772f3a8 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -7,7 +7,7 @@ use bevy_core_pipeline::prelude::Camera3dBundle;
 use bevy_ecs::{entity::Entity, world::World};
 use bevy_hierarchy::{BuildWorldChildren, WorldChildBuilder};
 use bevy_log::{error, warn};
-use bevy_math::{Mat4, Radians, Vec3};
+use bevy_math::{Mat4, Vec3};
 use bevy_pbr::{
     AlphaMode, DirectionalLight, DirectionalLightBundle, PbrBundle, PointLight, PointLightBundle,
     SpotLight, SpotLightBundle, StandardMaterial, MAX_JOINTS,
@@ -1101,8 +1101,8 @@ fn load_node(
                                 intensity: light.intensity() * std::f32::consts::PI * 4.0,
                                 range: light.range().unwrap_or(20.0),
                                 radius: light.range().unwrap_or(0.0),
-                                inner_angle: Radians(inner_cone_angle),
-                                outer_angle: Radians(outer_cone_angle),
+                                inner_angle: inner_cone_angle,
+                                outer_angle: outer_cone_angle,
                                 ..Default::default()
                             },
                             ..Default::default()
diff --git a/crates/bevy_pbr/src/light.rs b/crates/bevy_pbr/src/light.rs
index f21ec10ee9d58..00a36c283282f 100644
--- a/crates/bevy_pbr/src/light.rs
+++ b/crates/bevy_pbr/src/light.rs
@@ -103,17 +103,18 @@ pub struct SpotLight {
     /// shadow map's texel size so that it can be small close to the camera and gets larger further
     /// away.
     pub shadow_normal_bias: f32,
+    // TODO: Replace these with `Radians` once it implements `Reflect`
     /// Angle defining the distance from the spot light direction to the outer limit
     /// of the light's cone of effect.
     /// `outer_angle` should be < `PI / 2.0`.
     /// `PI / 2.0` defines a hemispherical spot light, but shadows become very blocky as the angle
     /// approaches this limit.
-    pub outer_angle: Radians,
+    pub outer_angle: f32,
     /// Angle defining the distance from the spot light direction to the inner limit
     /// of the light's cone of effect.
     /// Light is attenuated from `inner_angle` to `outer_angle` to give a smooth falloff.
     /// `inner_angle` should be <= `outer_angle`
-    pub inner_angle: Radians,
+    pub inner_angle: f32,
 }
 
 impl SpotLight {
@@ -132,8 +133,8 @@ impl Default for SpotLight {
             shadows_enabled: false,
             shadow_depth_bias: Self::DEFAULT_SHADOW_DEPTH_BIAS,
             shadow_normal_bias: Self::DEFAULT_SHADOW_NORMAL_BIAS,
-            inner_angle: Radians::ZERO,
-            outer_angle: Radians::FRAC_PI_4,
+            inner_angle: 0.0,
+            outer_angle: std::f32::consts::FRAC_PI_4,
         }
     }
 }
@@ -1255,7 +1256,7 @@ pub(crate) fn assign_lights_to_clusters(
                         transform: *transform,
                         shadows_enabled: spot_light.shadows_enabled,
                         range: spot_light.range,
-                        spot_light_angle: Some(spot_light.outer_angle),
+                        spot_light_angle: Some(Radians(spot_light.outer_angle)),
                         render_layers: maybe_layers.copied().unwrap_or_default(),
                     }
                 },
@@ -1951,7 +1952,7 @@ pub fn update_spot_light_frusta(
         let view_backward = transform.back();
 
         let spot_view = spot_light_view_matrix(transform);
-        let spot_projection = spot_light_projection_matrix(spot_light.outer_angle);
+        let spot_projection = spot_light_projection_matrix(Radians(spot_light.outer_angle));
         let view_projection = spot_projection * spot_view.inverse();
 
         *frustum = Frustum::from_view_projection_custom_far(
diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
index d871d5379b8bb..c84262b4eb743 100644
--- a/crates/bevy_pbr/src/render/light.rs
+++ b/crates/bevy_pbr/src/render/light.rs
@@ -415,7 +415,10 @@ pub fn extract_lights(
                         shadow_normal_bias: spot_light.shadow_normal_bias
                             * texel_size
                             * std::f32::consts::SQRT_2,
-                        spot_light_angles: Some((spot_light.inner_angle, spot_light.outer_angle)),
+                        spot_light_angles: Some((
+                            Radians(spot_light.inner_angle),
+                            Radians(spot_light.outer_angle),
+                        )),
                     },
                     render_visible_entities,
                 ),
diff --git a/crates/bevy_reflect/src/impls/angle.rs b/crates/bevy_reflect/src/impls/angle.rs
deleted file mode 100644
index 6820eca864d0b..0000000000000
--- a/crates/bevy_reflect/src/impls/angle.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use crate::prelude::ReflectDefault;
-use crate::{self as bevy_reflect, ReflectDeserialize, ReflectSerialize};
-use bevy_reflect_derive::impl_reflect_value;
-
-impl_reflect_value!(::bevy_math::Radians(
-    Debug,
-    Default,
-    PartialEq,
-    Serialize,
-    Deserialize,
-));
diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
index d0900a59b7510..3ed140c6f207b 100644
--- a/crates/bevy_reflect/src/lib.rs
+++ b/crates/bevy_reflect/src/lib.rs
@@ -490,7 +490,6 @@ mod impls {
     #[cfg(feature = "smol_str")]
     mod smol_str;
 
-    mod angle;
     mod std;
     mod uuid;
 }

From 5ac1969b4470b271f348feddeb784898ab4db5b8 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 19:57:27 +0200
Subject: [PATCH 10/21] Remove `bevy_internal` imports

---
 examples/stress_tests/transform_hierarchy.rs | 1 -
 examples/tools/gamepad_viewer.rs             | 1 -
 2 files changed, 2 deletions(-)

diff --git a/examples/stress_tests/transform_hierarchy.rs b/examples/stress_tests/transform_hierarchy.rs
index 5901182eb087f..71b15db5a1550 100644
--- a/examples/stress_tests/transform_hierarchy.rs
+++ b/examples/stress_tests/transform_hierarchy.rs
@@ -19,7 +19,6 @@
 //! | `humanoids_mixed`    | 2000 active and 2000 inactive humanoid rigs.                      |
 
 use bevy::prelude::*;
-use bevy_internal::math::Radians;
 use rand::Rng;
 
 /// pre-defined test configurations with name
diff --git a/examples/tools/gamepad_viewer.rs b/examples/tools/gamepad_viewer.rs
index e3fd08b5d6823..d302eee239528 100644
--- a/examples/tools/gamepad_viewer.rs
+++ b/examples/tools/gamepad_viewer.rs
@@ -7,7 +7,6 @@ use bevy::{
     prelude::*,
     sprite::{Anchor, MaterialMesh2dBundle, Mesh2dHandle},
 };
-use bevy_internal::math::Radians;
 
 const BUTTON_RADIUS: f32 = 25.;
 const BUTTON_CLUSTER_RADIUS: f32 = 50.;

From 4faf37622becc62caf633252ad12772ca204e740 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 20:25:30 +0200
Subject: [PATCH 11/21] Fix `arc_2d` gizmo doc example

---
 crates/bevy_gizmos/src/arcs.rs | 20 ++++++++++++++++----
 examples/2d/2d_gizmos.rs       |  2 +-
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_gizmos/src/arcs.rs b/crates/bevy_gizmos/src/arcs.rs
index 21b4d47dbdef7..158827128e1ff 100644
--- a/crates/bevy_gizmos/src/arcs.rs
+++ b/crates/bevy_gizmos/src/arcs.rs
@@ -17,9 +17,9 @@ impl<'s> Gizmos<'s> {
     /// # Arguments
     /// - `position` sets the center of this circle.
     /// - `radius` controls the distance from `position` to this arc, and thus its curvature.
-    /// - `direction_angle` sets the clockwise  angle in radians between `Vec2::Y` and
+    /// - `direction_angle` sets the clockwise angle between `Vec2::Y` and
     /// the vector from `position` to the midpoint of the arc.
-    /// - `arc_angle` sets the length of this arc, in radians.
+    /// - `arc_angle` sets the length of this arc.
     ///
     /// # Example
     /// ```
@@ -28,12 +28,24 @@ impl<'s> Gizmos<'s> {
     /// # use bevy_math::prelude::*;
     /// # use std::f32::consts::PI;
     /// fn system(mut gizmos: Gizmos) {
-    ///     gizmos.arc_2d(Vec2::ZERO, 0., PI / 4., 1., Color::GREEN);
+    ///     gizmos.arc_2d(
+    ///         Vec2::ZERO,
+    ///         Radians::ZERO,
+    ///         Radians::FRAC_PI_4,
+    ///         1.,
+    ///         Color::GREEN
+    ///     );
     ///
     ///     // Arcs have 32 line-segments by default.
     ///     // You may want to increase this for larger arcs.
     ///     gizmos
-    ///         .arc_2d(Vec2::ZERO, 0., PI / 4., 5., Color::RED)
+    ///         .arc_2d(
+    ///             Vec2::ZERO,
+    ///             Radians::ZERO,
+    ///             Radians::FRAC_PI_4,
+    ///             5.,
+    ///             Color::RED
+    ///         )
     ///         .segments(64);
     /// }
     /// # bevy_ecs::system::assert_is_system(system);
diff --git a/examples/2d/2d_gizmos.rs b/examples/2d/2d_gizmos.rs
index 30228e1ef062c..d5eccfc487f24 100644
--- a/examples/2d/2d_gizmos.rs
+++ b/examples/2d/2d_gizmos.rs
@@ -55,7 +55,7 @@ fn system(mut gizmos: Gizmos, time: Res<Time>) {
     gizmos.arc_2d(
         Vec2::ZERO,
         Radians(sin / 10.),
-        Radians(PI / 2.),
+        Radians::FRAC_PI_2,
         350.,
         Color::ORANGE_RED,
     );

From 92b5dcc02338d0a637250aa2d892542210b07d80 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 20:40:52 +0200
Subject: [PATCH 12/21] Fix angle types in examples

---
 crates/bevy_math/src/angle/degrees.rs | 1 +
 crates/bevy_math/src/angle/radians.rs | 1 +
 examples/3d/lighting.rs               | 4 ++--
 examples/3d/spotlight.rs              | 6 +++---
 4 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_math/src/angle/degrees.rs b/crates/bevy_math/src/angle/degrees.rs
index 87e54adcde1bf..ace12b2470b06 100644
--- a/crates/bevy_math/src/angle/degrees.rs
+++ b/crates/bevy_math/src/angle/degrees.rs
@@ -36,6 +36,7 @@ use crate::{Angle, Radians};
 /// // Small threshold for floating point error
 /// assert!((normalized - alpha).abs() < Degrees(0.000001));
 /// ```
+// TODO: Reflect
 #[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 pub struct Degrees(pub f32);
diff --git a/crates/bevy_math/src/angle/radians.rs b/crates/bevy_math/src/angle/radians.rs
index 90b9d76db75b0..4e8734ec9acc1 100644
--- a/crates/bevy_math/src/angle/radians.rs
+++ b/crates/bevy_math/src/angle/radians.rs
@@ -36,6 +36,7 @@ use crate::{Angle, Degrees};
 /// // Small threshold for floating point error
 /// assert!((normalized - alpha).abs() < Radians(0.000001));
 /// ```
+// TODO: Reflect
 #[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 pub struct Radians(pub f32);
diff --git a/examples/3d/lighting.rs b/examples/3d/lighting.rs
index 221c4b4c98a45..25a967aaf23c5 100644
--- a/examples/3d/lighting.rs
+++ b/examples/3d/lighting.rs
@@ -153,8 +153,8 @@ fn setup(
                 intensity: 1600.0, // lumens - roughly a 100W non-halogen incandescent bulb
                 color: Color::GREEN,
                 shadows_enabled: true,
-                inner_angle: Radians(0.6),
-                outer_angle: Radians(0.8),
+                inner_angle: 0.6,
+                outer_angle: 0.8,
                 ..default()
             },
             ..default()
diff --git a/examples/3d/spotlight.rs b/examples/3d/spotlight.rs
index 1a5fa00734805..23265e61162a7 100644
--- a/examples/3d/spotlight.rs
+++ b/examples/3d/spotlight.rs
@@ -90,8 +90,8 @@ fn setup(
                         intensity: 200.0, // lumens
                         color: Color::WHITE,
                         shadows_enabled: true,
-                        inner_angle: Radians::FRAC_PI_4 * 0.85,
-                        outer_angle: Radians::FRAC_PI_4,
+                        inner_angle: std::f32::consts::FRAC_PI_4 * 0.85,
+                        outer_angle: std::f32::consts::FRAC_PI_4,
                         ..default()
                     },
                     ..default()
@@ -134,7 +134,7 @@ fn light_sway(time: Res<Time>, mut query: Query<(&mut Transform, &mut SpotLight)
             (time.elapsed_seconds() * 3.0).sin() * 0.5,
             0.0,
         );
-        let angle = Radians(((time.elapsed_seconds() * 1.2).sin() + 1.0) * (FRAC_PI_4 - 0.1));
+        let angle = ((time.elapsed_seconds() * 1.2).sin() + 1.0) * (FRAC_PI_4 - 0.1);
         angles.inner_angle = angle * 0.8;
         angles.outer_angle = angle;
     }

From 1f8c067a4b03e11e34e8c0c16bda71843a6a7405 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 21:04:21 +0200
Subject: [PATCH 13/21] Add doc alias for `Angle::FULL`

---
 crates/bevy_math/src/angle/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_math/src/angle/mod.rs b/crates/bevy_math/src/angle/mod.rs
index 0c0bad67dbeb3..6b3ea435b55c1 100644
--- a/crates/bevy_math/src/angle/mod.rs
+++ b/crates/bevy_math/src/angle/mod.rs
@@ -33,7 +33,7 @@ pub trait Angle:
     #[doc(alias = "STRAIGHT_ANGLE")]
     const HALF: Self;
     /// A `360` degree angle (perigon). Equivalent to `2π` radians.
-    #[doc(alias = "FULL_ANGLE")]
+    #[doc(alias("PERIGON", "FULL_ANGLE"))]
     const FULL: Self;
 
     /// Creates a new angle.

From 8f9b4898e7baedc626dc7717f63dcbfd9fa5afee Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 23:35:55 +0200
Subject: [PATCH 14/21] Fix angle `PartialEq`/`PartialOrd` for angles

---
 crates/bevy_math/src/angle/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_math/src/angle/mod.rs b/crates/bevy_math/src/angle/mod.rs
index 6b3ea435b55c1..19e34818a7d55 100644
--- a/crates/bevy_math/src/angle/mod.rs
+++ b/crates/bevy_math/src/angle/mod.rs
@@ -155,7 +155,7 @@ impl PartialEq<Radians> for Degrees {
 
 impl PartialEq<Degrees> for Radians {
     fn eq(&self, other: &Degrees) -> bool {
-        *self == other.to_radians()
+        self.to_degrees() == *other
     }
 }
 
@@ -167,7 +167,7 @@ impl PartialOrd<Radians> for Degrees {
 
 impl PartialOrd<Degrees> for Radians {
     fn partial_cmp(&self, other: &Degrees) -> Option<std::cmp::Ordering> {
-        self.partial_cmp(&other.to_radians())
+        self.to_degrees().partial_cmp(other)
     }
 }
 

From d7581f7b20c909dc1b6adc791a35dae8436f2674 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 30 Dec 2023 23:36:27 +0200
Subject: [PATCH 15/21] Fix `Angle::normalized` condition

---
 crates/bevy_math/src/angle/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_math/src/angle/mod.rs b/crates/bevy_math/src/angle/mod.rs
index 19e34818a7d55..ce7e96f117980 100644
--- a/crates/bevy_math/src/angle/mod.rs
+++ b/crates/bevy_math/src/angle/mod.rs
@@ -75,7 +75,7 @@ pub trait Angle:
     /// Normalizes the angle to be within the range of `[0, 360)` degrees or `[0, 2π)` radians.
     #[inline]
     fn normalized(self) -> Self {
-        if self < Self::FULL && self > Self::ZERO {
+        if self < Self::FULL && self >= Self::ZERO {
             self
         } else {
             let remainder = self % Self::FULL;

From 398f4bf0860f0252107027c404dfbe8d762f0454 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sun, 31 Dec 2023 00:39:51 +0200
Subject: [PATCH 16/21] Remove mul between two angles and add/sub f32, make div
 and rem between angles return f32

---
 crates/bevy_math/src/angle/degrees.rs |  46 +----------
 crates/bevy_math/src/angle/mod.rs     | 105 ++++----------------------
 crates/bevy_math/src/angle/radians.rs |  78 +------------------
 3 files changed, 22 insertions(+), 207 deletions(-)

diff --git a/crates/bevy_math/src/angle/degrees.rs b/crates/bevy_math/src/angle/degrees.rs
index ace12b2470b06..3a671de4cc664 100644
--- a/crates/bevy_math/src/angle/degrees.rs
+++ b/crates/bevy_math/src/angle/degrees.rs
@@ -115,14 +115,6 @@ impl Sub for Degrees {
     }
 }
 
-impl Mul for Degrees {
-    type Output = Self;
-
-    fn mul(self, rhs: Degrees) -> Self::Output {
-        Self(self.0 * rhs.0)
-    }
-}
-
 impl Mul<f32> for Degrees {
     type Output = Self;
 
@@ -140,10 +132,10 @@ impl Mul<Degrees> for f32 {
 }
 
 impl Div for Degrees {
-    type Output = Self;
+    type Output = f32;
 
     fn div(self, rhs: Self) -> Self::Output {
-        Self(self.0 / rhs.0)
+        self.0 / rhs.0
     }
 }
 
@@ -156,10 +148,10 @@ impl Div<f32> for Degrees {
 }
 
 impl Rem for Degrees {
-    type Output = Self;
+    type Output = f32;
 
     fn rem(self, rhs: Self) -> Self::Output {
-        Self(self.0 % rhs.0)
+        self.0 % rhs.0
     }
 }
 
@@ -185,54 +177,24 @@ impl AddAssign for Degrees {
     }
 }
 
-impl AddAssign<f32> for Degrees {
-    fn add_assign(&mut self, rhs: f32) {
-        self.0 += rhs;
-    }
-}
-
 impl SubAssign for Degrees {
     fn sub_assign(&mut self, rhs: Degrees) {
         self.0 -= rhs.0;
     }
 }
 
-impl SubAssign<f32> for Degrees {
-    fn sub_assign(&mut self, rhs: f32) {
-        self.0 -= rhs;
-    }
-}
-
-impl MulAssign for Degrees {
-    fn mul_assign(&mut self, rhs: Degrees) {
-        self.0 *= rhs.0;
-    }
-}
-
 impl MulAssign<f32> for Degrees {
     fn mul_assign(&mut self, rhs: f32) {
         self.0 *= rhs;
     }
 }
 
-impl DivAssign for Degrees {
-    fn div_assign(&mut self, rhs: Degrees) {
-        self.0 /= rhs.0;
-    }
-}
-
 impl DivAssign<f32> for Degrees {
     fn div_assign(&mut self, rhs: f32) {
         self.0 /= rhs;
     }
 }
 
-impl RemAssign for Degrees {
-    fn rem_assign(&mut self, rhs: Degrees) {
-        self.0 %= rhs.0;
-    }
-}
-
 impl RemAssign<f32> for Degrees {
     fn rem_assign(&mut self, rhs: f32) {
         self.0 %= rhs;
diff --git a/crates/bevy_math/src/angle/mod.rs b/crates/bevy_math/src/angle/mod.rs
index ce7e96f117980..cea3513bf04ee 100644
--- a/crates/bevy_math/src/angle/mod.rs
+++ b/crates/bevy_math/src/angle/mod.rs
@@ -1,6 +1,4 @@
-use std::ops::{
-    Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign,
-};
+use std::ops::{Add, AddAssign, Div, Neg, Rem, Sub, SubAssign};
 
 mod degrees;
 mod radians;
@@ -15,12 +13,13 @@ pub trait Angle:
     + Copy
     + Add<Output = Self>
     + Sub<Output = Self>
-    + Mul<Output = Self>
-    + Div<Output = Self>
-    + Rem<Output = Self>
+    + Div<Output = f32>
+    + Rem<Output = f32>
     + Neg<Output = Self>
     + PartialEq
     + PartialOrd
+    + From<Degrees>
+    + From<Radians>
 {
     /// An angle of zero.
     const ZERO: Self;
@@ -78,7 +77,7 @@ pub trait Angle:
         if self < Self::FULL && self >= Self::ZERO {
             self
         } else {
-            let remainder = self % Self::FULL;
+            let remainder = Self::new(self % Self::FULL);
             if remainder >= Self::ZERO {
                 remainder
             } else {
@@ -121,30 +120,6 @@ pub trait Angle:
     {
         Output::from(self) - Output::from(angle)
     }
-
-    /// Multiplies `self` by the given `angle`, returning the inferred type of angle.
-    fn mul_angle<T: Angle, Output: Angle>(self, angle: T) -> Output
-    where
-        Output: From<Self> + From<T>,
-    {
-        Output::from(self) * Output::from(angle)
-    }
-
-    /// Divides `self` by the given `angle`, returning the inferred type of angle.
-    fn div_angle<T: Angle, Output: Angle>(self, angle: T) -> Output
-    where
-        Output: From<Self> + From<T>,
-    {
-        Output::from(self) + Output::from(angle)
-    }
-
-    /// Computes the remainder of `self` divided by the given `angle`, returning the inferred type of angle.
-    fn rem_angle<T: Angle, Output: Angle>(self, angle: T) -> Output
-    where
-        Output: From<Self> + From<T>,
-    {
-        Output::from(self) % Output::from(angle)
-    }
 }
 
 impl PartialEq<Radians> for Degrees {
@@ -203,51 +178,35 @@ impl Sub<Degrees> for Radians {
     }
 }
 
-impl Mul<Radians> for Degrees {
-    type Output = Radians;
-
-    fn mul(self, rhs: Radians) -> Self::Output {
-        self.to_radians() * rhs
-    }
-}
-
-impl Mul<Degrees> for Radians {
-    type Output = Radians;
-
-    fn mul(self, rhs: Degrees) -> Self::Output {
-        self * rhs.to_radians()
-    }
-}
-
 impl Div<Radians> for Degrees {
-    type Output = Radians;
+    type Output = f32;
 
     fn div(self, rhs: Radians) -> Self::Output {
-        self.to_radians() / rhs
+        self.0 / rhs.0.to_degrees()
     }
 }
 
 impl Div<Degrees> for Radians {
-    type Output = Radians;
+    type Output = f32;
 
     fn div(self, rhs: Degrees) -> Self::Output {
-        self / rhs.to_radians()
+        self.0.to_degrees() / rhs.0
     }
 }
 
 impl Rem<Radians> for Degrees {
-    type Output = Radians;
+    type Output = f32;
 
     fn rem(self, rhs: Radians) -> Self::Output {
-        self.to_radians() % rhs
+        self.0 % rhs.0.to_degrees()
     }
 }
 
 impl Rem<Degrees> for Radians {
-    type Output = Radians;
+    type Output = f32;
 
     fn rem(self, rhs: Degrees) -> Self::Output {
-        self % rhs.to_radians()
+        self.0.to_degrees() % rhs.0
     }
 }
 
@@ -274,39 +233,3 @@ impl SubAssign<Degrees> for Radians {
         *self -= rhs.to_radians();
     }
 }
-
-impl MulAssign<Radians> for Degrees {
-    fn mul_assign(&mut self, rhs: Radians) {
-        *self *= rhs.to_degrees();
-    }
-}
-
-impl MulAssign<Degrees> for Radians {
-    fn mul_assign(&mut self, rhs: Degrees) {
-        *self *= rhs.to_radians();
-    }
-}
-
-impl DivAssign<Radians> for Degrees {
-    fn div_assign(&mut self, rhs: Radians) {
-        *self /= rhs.to_degrees();
-    }
-}
-
-impl DivAssign<Degrees> for Radians {
-    fn div_assign(&mut self, rhs: Degrees) {
-        *self /= rhs.to_radians();
-    }
-}
-
-impl RemAssign<Radians> for Degrees {
-    fn rem_assign(&mut self, rhs: Radians) {
-        *self %= rhs.to_degrees();
-    }
-}
-
-impl RemAssign<Degrees> for Radians {
-    fn rem_assign(&mut self, rhs: Degrees) {
-        *self %= rhs.to_radians();
-    }
-}
diff --git a/crates/bevy_math/src/angle/radians.rs b/crates/bevy_math/src/angle/radians.rs
index 4e8734ec9acc1..1e36d27905309 100644
--- a/crates/bevy_math/src/angle/radians.rs
+++ b/crates/bevy_math/src/angle/radians.rs
@@ -124,22 +124,6 @@ impl Add for Radians {
     }
 }
 
-impl Add<f32> for Radians {
-    type Output = Self;
-
-    fn add(self, rhs: f32) -> Self::Output {
-        Self(self.0 + rhs)
-    }
-}
-
-impl Add<Radians> for f32 {
-    type Output = Radians;
-
-    fn add(self, rhs: Radians) -> Self::Output {
-        Radians(self + rhs.0)
-    }
-}
-
 impl Sub for Radians {
     type Output = Self;
 
@@ -148,30 +132,6 @@ impl Sub for Radians {
     }
 }
 
-impl Sub<f32> for Radians {
-    type Output = Self;
-
-    fn sub(self, rhs: f32) -> Self::Output {
-        Self(self.0 - rhs)
-    }
-}
-
-impl Sub<Radians> for f32 {
-    type Output = Radians;
-
-    fn sub(self, rhs: Radians) -> Self::Output {
-        Radians(self - rhs.0)
-    }
-}
-
-impl Mul for Radians {
-    type Output = Self;
-
-    fn mul(self, rhs: Radians) -> Self::Output {
-        Self(self.0 * rhs.0)
-    }
-}
-
 impl Mul<f32> for Radians {
     type Output = Self;
 
@@ -189,10 +149,10 @@ impl Mul<Radians> for f32 {
 }
 
 impl Div for Radians {
-    type Output = Self;
+    type Output = f32;
 
     fn div(self, rhs: Self) -> Self::Output {
-        Self(self.0 / rhs.0)
+        self.0 / rhs.0
     }
 }
 
@@ -205,10 +165,10 @@ impl Div<f32> for Radians {
 }
 
 impl Rem for Radians {
-    type Output = Self;
+    type Output = f32;
 
     fn rem(self, rhs: Self) -> Self::Output {
-        Self(self.0 % rhs.0)
+        self.0 % rhs.0
     }
 }
 
@@ -234,54 +194,24 @@ impl AddAssign for Radians {
     }
 }
 
-impl AddAssign<f32> for Radians {
-    fn add_assign(&mut self, rhs: f32) {
-        self.0 += rhs;
-    }
-}
-
 impl SubAssign for Radians {
     fn sub_assign(&mut self, rhs: Radians) {
         self.0 -= rhs.0;
     }
 }
 
-impl SubAssign<f32> for Radians {
-    fn sub_assign(&mut self, rhs: f32) {
-        self.0 -= rhs;
-    }
-}
-
-impl MulAssign for Radians {
-    fn mul_assign(&mut self, rhs: Radians) {
-        self.0 *= rhs.0;
-    }
-}
-
 impl MulAssign<f32> for Radians {
     fn mul_assign(&mut self, rhs: f32) {
         self.0 *= rhs;
     }
 }
 
-impl DivAssign for Radians {
-    fn div_assign(&mut self, rhs: Radians) {
-        self.0 /= rhs.0;
-    }
-}
-
 impl DivAssign<f32> for Radians {
     fn div_assign(&mut self, rhs: f32) {
         self.0 /= rhs;
     }
 }
 
-impl RemAssign for Radians {
-    fn rem_assign(&mut self, rhs: Radians) {
-        self.0 %= rhs.0;
-    }
-}
-
 impl RemAssign<f32> for Radians {
     fn rem_assign(&mut self, rhs: f32) {
         self.0 %= rhs;

From 402a220ef3abc2ae73dd43149ef496f3ad65495e Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sun, 31 Dec 2023 00:42:52 +0200
Subject: [PATCH 17/21] Remove unnecessary `Radians` usage

---
 crates/bevy_gizmos/src/circles.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_gizmos/src/circles.rs b/crates/bevy_gizmos/src/circles.rs
index 98995dd26ef9f..d24dec62e350e 100644
--- a/crates/bevy_gizmos/src/circles.rs
+++ b/crates/bevy_gizmos/src/circles.rs
@@ -4,7 +4,7 @@
 //! and assorted support items.
 
 use crate::prelude::Gizmos;
-use bevy_math::{Angle, Quat, Radians, Vec2, Vec3};
+use bevy_math::{Quat, Vec2, Vec3};
 use bevy_render::color::Color;
 use std::f32::consts::TAU;
 
@@ -12,7 +12,7 @@ pub(crate) const DEFAULT_CIRCLE_SEGMENTS: usize = 32;
 
 fn circle_inner(radius: f32, segments: usize) -> impl Iterator<Item = Vec2> {
     (0..segments + 1).map(move |i| {
-        let angle = Radians(i as f32 * TAU / segments as f32);
+        let angle = i as f32 * TAU / segments as f32;
         Vec2::from(angle.sin_cos()) * radius
     })
 }

From a96dc3b709c9140b9b1274fd84aa831155f4cd7b Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sun, 31 Dec 2023 00:44:07 +0200
Subject: [PATCH 18/21] Add missing `.abs()`

---
 crates/bevy_gizmos/src/arcs.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_gizmos/src/arcs.rs b/crates/bevy_gizmos/src/arcs.rs
index 158827128e1ff..a3f9e6287aaa3 100644
--- a/crates/bevy_gizmos/src/arcs.rs
+++ b/crates/bevy_gizmos/src/arcs.rs
@@ -96,7 +96,9 @@ impl Drop for Arc2dBuilder<'_, '_> {
             Some(segments) => segments,
             // Do a linear interpolation between 1 and `DEFAULT_CIRCLE_SEGMENTS`
             // using the arc angle as scalar.
-            None => ((self.arc_angle.0 / TAU) * DEFAULT_CIRCLE_SEGMENTS as f32).ceil() as usize,
+            None => {
+                ((self.arc_angle.abs().0 / TAU) * DEFAULT_CIRCLE_SEGMENTS as f32).ceil() as usize
+            }
         };
 
         let positions = arc_inner(self.direction_angle, self.arc_angle, self.radius, segments)

From 8d3da83f7279f3faea580174a52462a3a088c8df Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sun, 31 Dec 2023 02:06:28 +0200
Subject: [PATCH 19/21] Revert some unnecessary changes

---
 crates/bevy_pbr/src/render/light.rs | 4 ++--
 examples/3d/spotlight.rs            | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
index c84262b4eb743..901688cfd6bb4 100644
--- a/crates/bevy_pbr/src/render/light.rs
+++ b/crates/bevy_pbr/src/render/light.rs
@@ -638,9 +638,9 @@ pub(crate) fn spot_light_view_matrix(transform: &GlobalTransform) -> Mat4 {
     )
 }
 
-pub(crate) fn spot_light_projection_matrix(angle: impl Into<Radians>) -> Mat4 {
+pub(crate) fn spot_light_projection_matrix(angle: Radians) -> Mat4 {
     // spot light projection FOV is 2x the angle from spot light center to outer edge
-    Mat4::perspective_infinite_reverse_rh(angle.into().0 * 2.0, 1.0, POINT_LIGHT_NEAR_Z)
+    Mat4::perspective_infinite_reverse_rh(angle.0 * 2.0, 1.0, POINT_LIGHT_NEAR_Z)
 }
 
 #[allow(clippy::too_many_arguments)]
diff --git a/examples/3d/spotlight.rs b/examples/3d/spotlight.rs
index 23265e61162a7..9331f01635d61 100644
--- a/examples/3d/spotlight.rs
+++ b/examples/3d/spotlight.rs
@@ -90,8 +90,8 @@ fn setup(
                         intensity: 200.0, // lumens
                         color: Color::WHITE,
                         shadows_enabled: true,
-                        inner_angle: std::f32::consts::FRAC_PI_4 * 0.85,
-                        outer_angle: std::f32::consts::FRAC_PI_4,
+                        inner_angle: PI / 4.0 * 0.85,
+                        outer_angle: PI / 4.0,
                         ..default()
                     },
                     ..default()

From 28683125b9f717da1d0cbd7764ec59023af23303 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Mon, 1 Jan 2024 03:17:43 +0200
Subject: [PATCH 20/21] Return left-hand operand for angle addition and
 subtraction

---
 crates/bevy_math/src/angle/mod.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_math/src/angle/mod.rs b/crates/bevy_math/src/angle/mod.rs
index cea3513bf04ee..1079103917362 100644
--- a/crates/bevy_math/src/angle/mod.rs
+++ b/crates/bevy_math/src/angle/mod.rs
@@ -147,10 +147,10 @@ impl PartialOrd<Degrees> for Radians {
 }
 
 impl Add<Radians> for Degrees {
-    type Output = Radians;
+    type Output = Degrees;
 
     fn add(self, rhs: Radians) -> Self::Output {
-        self.to_radians() + rhs
+        self + rhs.to_degrees()
     }
 }
 
@@ -163,10 +163,10 @@ impl Add<Degrees> for Radians {
 }
 
 impl Sub<Radians> for Degrees {
-    type Output = Radians;
+    type Output = Degrees;
 
     fn sub(self, rhs: Radians) -> Self::Output {
-        self.to_radians() - rhs
+        self - rhs.to_degrees()
     }
 }
 

From 275fe57cde6897a0eadb5a13a36173ac2d08e580 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Mon, 1 Jan 2024 14:00:00 +0200
Subject: [PATCH 21/21] Remove `add_angle` and `sub_angle`, allow conversion
 from angle types to `Angle`

---
 crates/bevy_math/src/angle/mod.rs | 19 +++----------------
 1 file changed, 3 insertions(+), 16 deletions(-)

diff --git a/crates/bevy_math/src/angle/mod.rs b/crates/bevy_math/src/angle/mod.rs
index 1079103917362..03a467e66897d 100644
--- a/crates/bevy_math/src/angle/mod.rs
+++ b/crates/bevy_math/src/angle/mod.rs
@@ -20,6 +20,9 @@ pub trait Angle:
     + PartialOrd
     + From<Degrees>
     + From<Radians>
+where
+    Degrees: From<Self>,
+    Radians: From<Self>,
 {
     /// An angle of zero.
     const ZERO: Self;
@@ -104,22 +107,6 @@ pub trait Angle:
     fn round(self) -> Self {
         Self::new(self.value().round())
     }
-
-    /// Adds the given `angle` to `self`, returning the inferred type of angle.
-    fn add_angle<T: Angle, Output: Angle>(self, angle: T) -> Output
-    where
-        Output: From<Self> + From<T>,
-    {
-        Output::from(self) + Output::from(angle)
-    }
-
-    /// Subtracts the given `angle` from `self`, returning the inferred type of angle.
-    fn sub_angle<T: Angle, Output: Angle>(self, angle: T) -> Output
-    where
-        Output: From<Self> + From<T>,
-    {
-        Output::from(self) - Output::from(angle)
-    }
 }
 
 impl PartialEq<Radians> for Degrees {