Fix naming in Basis::to_euler_inner

Make `Projection` use `f64`s
Make `Basis2D` crate-public instead of public

Author: lilizoey

godot-core/src/builtin/basis.rs

@@ -217,17 +217,17 @@ impl Basis {
                         // return the simplest form (human friendlier in editor and scripts)
                         Vec3::new(0.0, f32::atan2(self.rows[0].z, self.rows[0].x), 0.0)
                     }
-                    _ => -Self::to_euler_inner(self.rows[0].z, row_a.yx(), col_c.yz(), col_b.zy())
+                    _ => -Self::to_euler_inner(self.rows[0].z, col_c.yz(), row_a.yx(), col_b.zy())
                         .yxz(),
                 }
             }
             EulerOrder::XZY => {
-                Self::to_euler_inner(self.rows[0].y, row_a.zx(), col_b.zy(), col_c.yz()).yzx()
+                Self::to_euler_inner(self.rows[0].y, col_b.zy(), row_a.zx(), col_c.yz()).yzx()
             }
             EulerOrder::YXZ => {
                 let major = self.rows[1].z;
-                let fst = row_b.xy();
-                let snd = col_c.xz();
+                let fst = col_c.xz();
+                let snd = row_b.xy();
                 let rest = row_a.yx();
                 match Self::is_between_neg1_1(major) {
                     // Is it a pure X rotation?
@@ -242,13 +242,13 @@ impl Basis {
                 }
             }
             EulerOrder::YZX => {
-                -Self::to_euler_inner(self.rows[1].x, col_a.zx(), row_b.zy(), row_c.yz()).yzx()
+                -Self::to_euler_inner(self.rows[1].x, row_b.zy(), col_a.zx(), row_c.yz()).yzx()
             }
             EulerOrder::ZXY => {
-                -Self::to_euler_inner(self.rows[2].y, col_b.xy(), row_c.xz(), row_a.zx())
+                -Self::to_euler_inner(self.rows[2].y, row_c.xz(), col_b.xy(), row_a.zx())
             }
             EulerOrder::ZYX => {
-                Self::to_euler_inner(self.rows[2].x, row_c.yz(), col_a.yx(), col_b.xy()).zxy()
+                Self::to_euler_inner(self.rows[2].x, col_a.yx(), row_c.yz(), col_b.xy()).zxy()
             }
         }
         .to_front()
@@ -275,8 +275,8 @@ impl Basis {
             Ordering::Less => glam::Vec3::new(FRAC_PI_2, -f32::atan2(rest.x, rest.y), 0.0),
             Ordering::Equal => glam::Vec3::new(
                 f32::asin(-major),
-                f32::atan2(snd.x, snd.y),
                 f32::atan2(fst.x, fst.y),
+                f32::atan2(snd.x, snd.y),
             ),
             // It's 1
             Ordering::Greater => glam::Vec3::new(-FRAC_PI_2, -f32::atan2(rest.x, rest.y), 0.0),

godot-core/src/builtin/projection.rs

@@ -83,23 +83,23 @@ impl Projection {
     #[allow(clippy::too_many_arguments)]
     pub fn create_for_hmd(
         eye: ProjectionEye,
-        aspect: f32,
-        intraocular_dist: f32,
-        display_width: f32,
-        display_to_lens: f32,
-        oversample: f32,
-        near: f32,
-        far: f32,
+        aspect: f64,
+        intraocular_dist: f64,
+        display_width: f64,
+        display_to_lens: f64,
+        oversample: f64,
+        near: f64,
+        far: f64,
     ) -> Self {
         InnerProjection::create_for_hmd(
             eye as i64,
-            aspect as f64,
-            intraocular_dist as f64,
-            display_width as f64,
-            display_to_lens as f64,
-            oversample as f64,
-            near as f64,
-            far as f64,
+            aspect,
+            intraocular_dist,
+            display_width,
+            display_to_lens,
+            oversample,
+            near,
+            far,
         )
     }
 
@@ -108,21 +108,14 @@ impl Projection {
     ///
     /// _Godot equivalent: Projection.create_frustum()_
     pub fn create_frustum(
-        left: f32,
-        right: f32,
-        bottom: f32,
-        top: f32,
-        near: f32,
-        far: f32,
+        left: f64,
+        right: f64,
+        bottom: f64,
+        top: f64,
+        near: f64,
+        far: f64,
     ) -> Self {
-        InnerProjection::create_frustum(
-            left as f64,
-            right as f64,
-            bottom as f64,
-            top as f64,
-            near as f64,
-            far as f64,
-        )
+        InnerProjection::create_frustum(left, right, bottom, top, near, far)
     }
 
     /// Creates a new Projection that projects positions in a frustum with the
@@ -133,43 +126,29 @@ impl Projection {
     ///
     /// _Godot equivalent: Projection.create_frustum_aspect()_
     pub fn create_frustum_aspect(
-        size: f32,
-        aspect: f32,
+        size: f64,
+        aspect: f64,
         offset: Vector2,
-        near: f32,
-        far: f32,
+        near: f64,
+        far: f64,
         flip_fov: bool,
     ) -> Self {
-        InnerProjection::create_frustum_aspect(
-            size as f64,
-            aspect as f64,
-            offset,
-            near as f64,
-            far as f64,
-            flip_fov,
-        )
+        InnerProjection::create_frustum_aspect(size, aspect, offset, near, far, flip_fov)
     }
 
     /// Creates a new Projection that projects positions using an orthogonal
     /// projection with the given clipping planes.
     ///
     /// _Godot equivalent: Projection.create_orthogonal()_
     pub fn create_orthogonal(
-        left: f32,
-        right: f32,
-        bottom: f32,
-        top: f32,
-        near: f32,
-        far: f32,
+        left: f64,
+        right: f64,
+        bottom: f64,
+        top: f64,
+        near: f64,
+        far: f64,
     ) -> Self {
-        InnerProjection::create_orthogonal(
-            left as f64,
-            right as f64,
-            bottom as f64,
-            top as f64,
-            near as f64,
-            far as f64,
-        )
+        InnerProjection::create_orthogonal(left, right, bottom, top, near, far)
     }
 
     /// Creates a new Projection that projects positions using an orthogonal
@@ -180,19 +159,13 @@ impl Projection {
     ///
     /// _Godot equivalent: Projection.create_orthogonal_aspect()_
     pub fn create_orthogonal_aspect(
-        size: f32,
-        aspect: f32,
-        near: f32,
-        far: f32,
+        size: f64,
+        aspect: f64,
+        near: f64,
+        far: f64,
         flip_fov: bool,
     ) -> Self {
-        InnerProjection::create_orthogonal_aspect(
-            size as f64,
-            aspect as f64,
-            near as f64,
-            far as f64,
-            flip_fov,
-        )
+        InnerProjection::create_orthogonal_aspect(size, aspect, near, far, flip_fov)
     }
 
     /// Creates a new Projection that projects positions using a perspective
@@ -204,19 +177,13 @@ impl Projection {
     ///
     /// _Godot equivalent: Projection.create_perspective()_
     pub fn create_perspective(
-        fov_y: f32,
-        aspect: f32,
-        near: f32,
-        far: f32,
+        fov_y: f64,
+        aspect: f64,
+        near: f64,
+        far: f64,
         flip_fov: bool,
     ) -> Self {
-        InnerProjection::create_perspective(
-            fov_y as f64,
-            aspect as f64,
-            near as f64,
-            far as f64,
-            flip_fov,
-        )
+        InnerProjection::create_perspective(fov_y, aspect, near, far, flip_fov)
     }
 
     /// Creates a new Projection that projects positions using a perspective
@@ -231,32 +198,32 @@ impl Projection {
     /// _Godot equivalent: Projection.create_perspective_hmd()_
     #[allow(clippy::too_many_arguments)]
     pub fn create_perspective_hmd(
-        fov_y: f32,
-        aspect: f32,
-        near: f32,
-        far: f32,
+        fov_y: f64,
+        aspect: f64,
+        near: f64,
+        far: f64,
         flip_fov: bool,
         eye: ProjectionEye,
-        intraocular_dist: f32,
-        convergence_dist: f32,
+        intraocular_dist: f64,
+        convergence_dist: f64,
     ) -> Self {
         InnerProjection::create_perspective_hmd(
-            fov_y as f64,
-            aspect as f64,
-            near as f64,
-            far as f64,
+            fov_y,
+            aspect,
+            near,
+            far,
             flip_fov,
             eye as i64,
-            intraocular_dist as f64,
-            convergence_dist as f64,
+            intraocular_dist,
+            convergence_dist,
         )
     }
 
     /// Return the determinant of the matrix.
     ///
     /// _Godot equivalent: Projection.determinant()_
-    pub fn determinant(&self) -> f32 {
-        self.glam(|mat| mat.determinant())
+    pub fn determinant(&self) -> f64 {
+        self.glam(|mat| mat.determinant()) as f64
     }
 
     /// Returns a copy of this Projection with the signs of the values of the Y
@@ -271,8 +238,8 @@ impl Projection {
     /// Returns the X:Y aspect ratio of this Projection's viewport.
     ///
     /// _Godot equivalent: Projection.get_aspect()_
-    pub fn aspect(&self) -> f32 {
-        self.as_inner().get_aspect() as f32
+    pub fn aspect(&self) -> f64 {
+        self.as_inner().get_aspect()
     }
 
     /// Returns the dimensions of the far clipping plane of the projection,
@@ -286,24 +253,24 @@ impl Projection {
     /// Returns the horizontal field of view of the projection (in degrees).
     ///
     /// _Godot equivalent: Projection.get_fov()_
-    pub fn fov(&self) -> f32 {
-        self.as_inner().get_fov() as f32
+    pub fn fov(&self) -> f64 {
+        self.as_inner().get_fov()
     }
 
     /// Returns the vertical field of view of a projection (in degrees) which
     /// has the given horizontal field of view (in degrees) and aspect ratio.
     ///
     /// _Godot equivalent: Projection.get_fovy()_
-    pub fn fovy_of(fov_x: f32, aspect: f32) -> f32 {
-        InnerProjection::get_fovy(fov_x as f64, aspect as f64) as f32
+    pub fn fovy_of(fov_x: f64, aspect: f64) -> f64 {
+        InnerProjection::get_fovy(fov_x, aspect)
     }
 
     /// Returns the factor by which the visible level of detail is scaled by
     /// this Projection.
     ///
     /// _Godot equivalent: Projection.get_lod_multiplier()_
-    pub fn lod_multiplier(&self) -> f32 {
-        self.as_inner().get_lod_multiplier() as f32
+    pub fn lod_multiplier(&self) -> f64 {
+        self.as_inner().get_lod_multiplier()
     }
 
     /// Returns the number of pixels with the given pixel width displayed per
@@ -334,16 +301,16 @@ impl Projection {
     /// clipped.
     ///
     /// _Godot equivalent: Projection.get_z_far()_
-    pub fn z_far(&self) -> f32 {
-        self.as_inner().get_z_far() as f32
+    pub fn z_far(&self) -> f64 {
+        self.as_inner().get_z_far()
     }
 
     /// Returns the distance for this Projection before which positions are
     /// clipped.
     ///
     /// _Godot equivalent: Projection.get_z_near()_
-    pub fn z_near(&self) -> f32 {
-        self.as_inner().get_z_near() as f32
+    pub fn z_near(&self) -> f64 {
+        self.as_inner().get_z_near()
     }
 
     /// Returns a Projection that performs the inverse of this Projection's
@@ -376,8 +343,8 @@ impl Projection {
     /// Note: The original Projection must be a perspective projection.
     ///
     /// _Godot equivalent: Projection.perspective_znear_adjusted()_
-    pub fn perspective_znear_adjusted(&self, new_znear: f32) -> Self {
-        self.as_inner().perspective_znear_adjusted(new_znear as f64)
+    pub fn perspective_znear_adjusted(&self, new_znear: f64) -> Self {
+        self.as_inner().perspective_znear_adjusted(new_znear)
     }
 
     #[doc(hidden)]