implement Display trait for some built-in types

Author: hapenia

check.sh

@@ -76,6 +76,18 @@ function findGodot() {
         echo "Found 'godot4.bat' script"
         godotBin="godot4.bat"
 
+    # This should come last: only use this as a last resort as usually `godot`
+    # refers to a Godot 3.x installation.
+    elif command -v godot &>/dev/null; then
+        # Check if `godot` actually is Godot 4.x
+        if godot --version | grep -qE "^4\\."; then
+            echo "Found 'godot' executable with version $(godot --version)"
+            godotBin="godot"
+        else
+            echo "Found 'godot' executable, but it has the incompatible version $(godot --version)"
+            exit 2
+        fi
+
     # Error case
     else
         echo "Godot executable not found"
@@ -99,7 +111,7 @@ for arg in "${args[@]}"; do
         ;;
     itest)
         findGodot
-        
+
         cmds+=("cargo $toolchain build -p itest $extraArgs")
         cmds+=("$godotBin --path itest/godot --headless")
         ;;

godot-core/src/builtin/aabb.rs

@@ -82,6 +82,13 @@ impl Aabb {
     */
 }
 
+impl std::fmt::Display for Aabb {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // Godot Output: [P: (_, _, _), S: (_, _, _)]
+        write!(f, "[P: {}, S: {}]", self.position, self.size)
+    }
+}
+
 impl GodotFfi for Aabb {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }

godot-core/src/builtin/color.rs

@@ -495,3 +495,9 @@ fn to_be_words(mut u: u64) -> [u16; 4] {
     let x = (u & 0xffff) as u16;
     [x, y, z, w]
 }
+
+impl std::fmt::Display for Color {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({}, {}, {}, {})", self.r, self.g, self.b, self.a)
+    }
+}

godot-core/src/builtin/plane.rs

@@ -138,6 +138,14 @@ impl GodotFfi for Plane {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 
+impl std::fmt::Display for Plane {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // e.g.
+        // [N: (0, 0, 0), D: 0]
+        write!(f, "[N: {}, D: {}]", self.normal, self.d)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

godot-core/src/builtin/projection.rs

@@ -9,7 +9,7 @@ use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
 
 use super::glam_helpers::{GlamConv, GlamType};
-use super::{inner::InnerProjection, Plane, Transform3D, Vector2, Vector4};
+use super::{inner::InnerProjection, Plane, Transform3D, Vector2, Vector4, Vector4Axis};
 use super::{real, RMat4, RealConv};
 
 /// A 4x4 matrix used for 3D projective transformations. It can represent
@@ -959,3 +959,56 @@ mod test {
         }
     }
 }
+
+impl std::fmt::Display for Projection {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // godot output:
+        // ```gdscript
+        // 1, 0, 0, 0
+        // 0, 1, 0, 0
+        // 0, 0, 1, 0
+        // 0, 0, 0, 1
+        // ```
+        write!(
+            f,
+            "\n{}, {}, {}, {}\n{}, {}, {}, {}\n{}, {}, {}, {}\n{}, {}, {}, {}\n",
+            // first row
+            self.cols[0][Vector4Axis::X],
+            self.cols[1][Vector4Axis::X],
+            self.cols[2][Vector4Axis::X],
+            self.cols[3][Vector4Axis::X],
+            // second row
+            self.cols[0][Vector4Axis::Y],
+            self.cols[1][Vector4Axis::Y],
+            self.cols[2][Vector4Axis::Y],
+            self.cols[3][Vector4Axis::Y],
+            // third row
+            self.cols[0][Vector4Axis::Z],
+            self.cols[1][Vector4Axis::Z],
+            self.cols[2][Vector4Axis::Z],
+            self.cols[3][Vector4Axis::Z],
+            // forth row
+            self.cols[0][Vector4Axis::W],
+            self.cols[1][Vector4Axis::W],
+            self.cols[2][Vector4Axis::W],
+            self.cols[3][Vector4Axis::W],
+        )
+    }
+}
+
+#[test]
+fn display_test() {
+    const TEST_DATA: [Vector4; 4] = [
+        Vector4::new(1.0, 2.5, 1.0, 0.5),
+        Vector4::new(0.0, 1.5, 2.0, 0.5),
+        Vector4::new(0.0, 0.0, 3.0, 2.5),
+        Vector4::new(3.0, 1.0, 4.0, 1.5),
+    ];
+    const EXPECTED_RESULT: &str = r"
+1, 0, 0, 3
+2.5, 1.5, 0, 1
+1, 2, 3, 4
+0.5, 0.5, 2.5, 1.5
+";
+    assert_eq!(format!("{}", Projection::new(TEST_DATA)), EXPECTED_RESULT)
+}

godot-core/src/builtin/rect2.rs

@@ -107,3 +107,11 @@ impl Rect2 {
 impl GodotFfi for Rect2 {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
+
+impl std::fmt::Display for Rect2 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // godot output be like:
+        // [P: (0, 0), S: (0, 0)]
+        write!(f, "[P: {}, S: {}]", self.position, self.size)
+    }
+}

godot-core/src/builtin/rect2i.rs

@@ -96,3 +96,11 @@ impl Rect2i {
 impl GodotFfi for Rect2i {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
+
+impl std::fmt::Display for Rect2i {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // godot output be like:
+        // [P: (0, 0), S: (0, 0)]
+        write!(f, "[P: {}, S: {}]", self.position, self.size)
+    }
+}

godot-core/src/builtin/rid.rs

@@ -81,6 +81,16 @@ impl Rid {
     }
 }
 
+impl std::fmt::Display for Rid {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // godot output: `RID(0)`
+        match self {
+            Rid::Valid(x) => write!(f, "RID({})", x),
+            Rid::Invalid => write!(f, "RID(0)"),
+        }
+    }
+}
+
 impl GodotFfi for Rid {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }

godot-core/src/builtin/transform2d.rs

@@ -494,7 +494,6 @@ impl Default for Basis2D {
 impl Display for Basis2D {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let [a, b] = self.cols;
-
         write!(f, "[a: {a}, b: {b})]")
     }
 }