Use SHOUT_CASE for ProjectionEye, ProjectionPlane, ColorChannelOrder

Bromeon · Bromeon · commit 20d8c7e76992 · 2024-05-26T10:58:19.000+02:00
diff --git a/godot-core/src/builtin/color.rs b/godot-core/src/builtin/color.rs
@@ -368,31 +368,43 @@ impl ApproxEq for Color {
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
 pub enum ColorChannelOrder {
     /// RGBA channel order. Godot's default.
-    Rgba,
+    RGBA,
 
     /// ABGR channel order. Reverse of the default RGBA order.
-    Abgr,
+    ABGR,
 
     /// ARGB channel order. More compatible with DirectX.
-    Argb,
+    ARGB,
+}
+
+#[allow(non_upper_case_globals)]
+impl ColorChannelOrder {
+    #[deprecated(note = "Renamed to `ColorChannelOrder::RGBA`.")]
+    pub const Rgba: Self = Self::RGBA;
+
+    #[deprecated(note = "Renamed to `ColorChannelOrder::ABGR`.")]
+    pub const Abgr: Self = Self::ABGR;
+
+    #[deprecated(note = "Renamed to `ColorChannelOrder::ARGB`.")]
+    pub const Argb: Self = Self::ARGB;
 }
 
 impl ColorChannelOrder {
     fn pack<T>(self, rgba: [T; 4]) -> [T; 4] {
         let [r, g, b, a] = rgba;
         match self {
-            ColorChannelOrder::Rgba => [r, g, b, a],
-            ColorChannelOrder::Abgr => [a, b, g, r],
-            ColorChannelOrder::Argb => [a, r, g, b],
+            ColorChannelOrder::RGBA => [r, g, b, a],
+            ColorChannelOrder::ABGR => [a, b, g, r],
+            ColorChannelOrder::ARGB => [a, r, g, b],
         }
     }
 
     fn unpack<T>(self, xyzw: [T; 4]) -> [T; 4] {
         let [x, y, z, w] = xyzw;
         match self {
-            ColorChannelOrder::Rgba => [x, y, z, w],
-            ColorChannelOrder::Abgr => [w, z, y, x],
-            ColorChannelOrder::Argb => [y, z, w, x],
+            ColorChannelOrder::RGBA => [x, y, z, w],
+            ColorChannelOrder::ABGR => [w, z, y, x],
+            ColorChannelOrder::ARGB => [y, z, w, x],
         }
     }
 }
diff --git a/godot-core/src/builtin/projection.rs b/godot-core/src/builtin/projection.rs
@@ -122,8 +122,8 @@ impl Projection {
         f2 = (f2 + add) * near;
 
         match eye {
-            ProjectionEye::Left => Self::create_frustum(-f2, f1, -f3, f3, near, far),
-            ProjectionEye::Right => Self::create_frustum(-f1, f2, -f3, f3, near, far),
+            ProjectionEye::LEFT => Self::create_frustum(-f2, f1, -f3, f3, near, far),
+            ProjectionEye::RIGHT => Self::create_frustum(-f1, f2, -f3, f3, near, far),
         }
     }
 
@@ -302,12 +302,12 @@ impl Projection {
         let frustumshift = (intraocular_dist * near * 0.5) / convergence_dist;
 
         let (left, right, model_translation) = match eye {
-            ProjectionEye::Left => (
+            ProjectionEye::LEFT => (
                 frustumshift - xmax,
                 xmax + frustumshift,
                 intraocular_dist / 2.0,
             ),
-            ProjectionEye::Right => (
+            ProjectionEye::RIGHT => (
                 -frustumshift - xmax,
                 xmax - frustumshift,
                 intraocular_dist / -2.0,
@@ -544,24 +544,45 @@ impl_godot_as_self!(Projection);
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 #[repr(C)]
 pub enum ProjectionPlane {
-    Near = 0,
-    Far = 1,
-    Left = 2,
-    Top = 3,
-    Right = 4,
-    Bottom = 5,
+    NEAR = 0,
+    FAR = 1,
+    LEFT = 2,
+    TOP = 3,
+    RIGHT = 4,
+    BOTTOM = 5,
+}
+
+#[allow(non_upper_case_globals)]
+impl ProjectionPlane {
+    #[deprecated(note = "Renamed to `ProjectionPlane::NEAR`")]
+    pub const Near: Self = Self::NEAR;
+
+    #[deprecated(note = "Renamed to `ProjectionPlane::FAR`")]
+    pub const Far: Self = Self::FAR;
+
+    #[deprecated(note = "Renamed to `ProjectionPlane::LEFT`")]
+    pub const Left: Self = Self::LEFT;
+
+    #[deprecated(note = "Renamed to `ProjectionPlane::TOP`")]
+    pub const Top: Self = Self::TOP;
+
+    #[deprecated(note = "Renamed to `ProjectionPlane::RIGHT`")]
+    pub const Right: Self = Self::RIGHT;
+
+    #[deprecated(note = "Renamed to `ProjectionPlane::BOTTOM`")]
+    pub const Bottom: Self = Self::BOTTOM;
 }
 
 impl ProjectionPlane {
     /// Convert from one of GDScript's `Projection.PLANE_*` integer constants.
     pub fn try_from_ord(ord: i64) -> Option<Self> {
         match ord {
-            0 => Some(Self::Near),
-            1 => Some(Self::Far),
-            2 => Some(Self::Left),
-            3 => Some(Self::Top),
-            4 => Some(Self::Right),
-            5 => Some(Self::Bottom),
+            0 => Some(Self::NEAR),
+            1 => Some(Self::FAR),
+            2 => Some(Self::LEFT),
+            3 => Some(Self::TOP),
+            4 => Some(Self::RIGHT),
+            5 => Some(Self::BOTTOM),
             _ => None,
         }
     }
@@ -571,16 +592,25 @@ impl ProjectionPlane {
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 #[repr(C)]
 pub enum ProjectionEye {
-    Left = 1,
-    Right = 2,
+    LEFT = 1,
+    RIGHT = 2,
+}
+
+#[allow(non_upper_case_globals)]
+impl ProjectionEye {
+    #[deprecated(note = "Renamed to `ProjectionEye::LEFT`")]
+    pub const Left: Self = Self::LEFT;
+
+    #[deprecated(note = "Renamed to `ProjectionEye::RIGHT`")]
+    pub const Right: Self = Self::RIGHT;
 }
 
 impl ProjectionEye {
     /// Convert from numbers `1` and `2`.
     pub fn try_from_ord(ord: i64) -> Option<Self> {
         match ord {
-            1 => Some(Self::Left),
-            2 => Some(Self::Right),
+            1 => Some(Self::LEFT),
+            2 => Some(Self::RIGHT),
             _ => None,
         }
     }
diff --git a/itest/rust/src/builtin_tests/color_test.rs b/itest/rust/src/builtin_tests/color_test.rs
@@ -21,15 +21,15 @@ fn color_from_rgba8() {
 fn color_from_u32() {
     const D: f32 = 255.0;
     assert_eq!(
-        Color::from_u32_rgba(0x01020304, ColorChannelOrder::Rgba),
+        Color::from_u32_rgba(0x01020304, ColorChannelOrder::RGBA),
         Color::from_rgba(1.0 / D, 2.0 / D, 3.0 / D, 4.0 / D)
     );
     assert_eq!(
-        Color::from_u32_rgba(0x01020304, ColorChannelOrder::Abgr),
+        Color::from_u32_rgba(0x01020304, ColorChannelOrder::ABGR),
         Color::from_rgba(4.0 / D, 3.0 / D, 2.0 / D, 1.0 / D)
     );
     assert_eq!(
-        Color::from_u32_rgba(0x01020304, ColorChannelOrder::Argb),
+        Color::from_u32_rgba(0x01020304, ColorChannelOrder::ARGB),
         Color::from_rgba(2.0 / D, 3.0 / D, 4.0 / D, 1.0 / D)
     );
 }
@@ -38,15 +38,15 @@ fn color_from_u32() {
 fn color_from_u64() {
     const D: f32 = 65535.0;
     assert_eq!(
-        Color::from_u64_rgba(0x0001000200030004, ColorChannelOrder::Rgba),
+        Color::from_u64_rgba(0x0001000200030004, ColorChannelOrder::RGBA),
         Color::from_rgba(1.0 / D, 2.0 / D, 3.0 / D, 4.0 / D)
     );
     assert_eq!(
-        Color::from_u64_rgba(0x0001000200030004, ColorChannelOrder::Abgr),
+        Color::from_u64_rgba(0x0001000200030004, ColorChannelOrder::ABGR),
         Color::from_rgba(4.0 / D, 3.0 / D, 2.0 / D, 1.0 / D)
     );
     assert_eq!(
-        Color::from_u64_rgba(0x0001000200030004, ColorChannelOrder::Argb),
+        Color::from_u64_rgba(0x0001000200030004, ColorChannelOrder::ARGB),
         Color::from_rgba(2.0 / D, 3.0 / D, 4.0 / D, 1.0 / D)
     );
 }
@@ -100,17 +100,17 @@ fn color_blend() {
 #[itest]
 fn color_to_u32() {
     let c = Color::from_html("#01020304").unwrap();
-    assert_eq!(c.to_u32(ColorChannelOrder::Rgba), 0x01020304);
-    assert_eq!(c.to_u32(ColorChannelOrder::Abgr), 0x04030201);
-    assert_eq!(c.to_u32(ColorChannelOrder::Argb), 0x04010203);
+    assert_eq!(c.to_u32(ColorChannelOrder::RGBA), 0x01020304);
+    assert_eq!(c.to_u32(ColorChannelOrder::ABGR), 0x04030201);
+    assert_eq!(c.to_u32(ColorChannelOrder::ARGB), 0x04010203);
 }
 
 #[itest]
 fn color_to_u64() {
     let c = Color::from_html("#01020304").unwrap();
-    assert_eq!(c.to_u64(ColorChannelOrder::Rgba), 0x0101_0202_0303_0404);
-    assert_eq!(c.to_u64(ColorChannelOrder::Abgr), 0x0404_0303_0202_0101);
-    assert_eq!(c.to_u64(ColorChannelOrder::Argb), 0x0404_0101_0202_0303);
+    assert_eq!(c.to_u64(ColorChannelOrder::RGBA), 0x0101_0202_0303_0404);
+    assert_eq!(c.to_u64(ColorChannelOrder::ABGR), 0x0404_0303_0202_0101);
+    assert_eq!(c.to_u64(ColorChannelOrder::ARGB), 0x0404_0101_0202_0303);
 }
 
 // Multiple specific cases because HSV->RGB conversion algorithm used is very dependent on Hue value, taking into account different values
