Impl Display for built-ins

Author: lilizoey

examples/dodge-the-creeps/rust/src/player.rs

@@ -53,7 +53,7 @@ impl Area2DVirtual for Player {
 
     fn ready(&mut self) {
         let viewport = self.base.get_viewport_rect();
-        self.screen_size = viewport.size();
+        self.screen_size = viewport.size;
         self.base.hide();
     }
 

godot-codegen/src/api_parser.rs

@@ -43,7 +43,7 @@ pub struct BuiltinClass {
     pub indexing_return_type: Option<String>,
     pub is_keyed: bool,
     pub members: Option<Vec<Member>>,
-    pub constants: Option<Vec<Constant>>,
+    // pub constants: Option<Vec<BuiltinConstant>>,
     pub enums: Option<Vec<BuiltinClassEnum>>, // no bitfield
     pub operators: Vec<Operator>,
     pub methods: Option<Vec<BuiltinClassMethod>>,
@@ -58,7 +58,7 @@ pub struct Class {
     pub is_instantiable: bool,
     pub inherits: Option<String>,
     // pub api_type: String,
-    // pub constants: Option<Vec<Constant>>,
+    pub constants: Option<Vec<ClassConstant>>,
     pub enums: Option<Vec<Enum>>,
     pub methods: Option<Vec<ClassMethod>>,
     // pub properties: Option<Vec<Property>>,
@@ -102,13 +102,18 @@ pub struct EnumConstant {
     pub value: i32,
 }
 
+pub type ClassConstant = EnumConstant;
+
+/*
+// Constants of builtin types have a string value like "Vector2(1, 1)", hence also a type field
 #[derive(DeJson)]
-pub struct Constant {
+pub struct BuiltinConstant {
     pub name: String,
     #[nserde(rename = "type")]
     pub type_: String,
     pub value: String,
 }
+*/
 
 #[derive(DeJson)]
 pub struct Operator {

godot-codegen/src/class_generator.rs

@@ -173,6 +173,7 @@ fn make_class(class: &Class, class_name: &TyName, ctx: &mut Context) -> Generate
     let constructor = make_constructor(class, ctx);
     let methods = make_methods(&class.methods, class_name, ctx);
     let enums = make_enums(&class.enums, class_name, ctx);
+    let constants = make_constants(&class.constants, class_name, ctx);
     let inherits_macro = format_ident!("inherits_transitive_{}", class_name.rust_ty);
     let all_bases = ctx.inheritance_tree().collect_all_bases(class_name);
     let virtual_trait = make_virtual_methods_trait(class, &all_bases, &virtual_trait_str, ctx);
@@ -205,6 +206,7 @@ fn make_class(class: &Class, class_name: &TyName, ctx: &mut Context) -> Generate
             impl #class_name {
                 #constructor
                 #methods
+                #constants
             }
             impl crate::obj::GodotClass for #class_name {
                 type Base = #base;
@@ -420,9 +422,8 @@ fn make_builtin_methods(
 }
 
 fn make_enums(enums: &Option<Vec<Enum>>, _class_name: &TyName, _ctx: &Context) -> TokenStream {
-    let enums = match enums {
-        Some(e) => e,
-        None => return TokenStream::new(),
+    let Some(enums) = enums else {
+        return TokenStream::new();
     };
 
     let definitions = enums.iter().map(util::make_enum_definition);
@@ -432,6 +433,22 @@ fn make_enums(enums: &Option<Vec<Enum>>, _class_name: &TyName, _ctx: &Context) -
     }
 }
 
+fn make_constants(
+    constants: &Option<Vec<ClassConstant>>,
+    _class_name: &TyName,
+    _ctx: &Context,
+) -> TokenStream {
+    let Some(constants) = constants else {
+        return TokenStream::new();
+    };
+
+    let definitions = constants.iter().map(util::make_constant_definition);
+
+    quote! {
+        #( #definitions )*
+    }
+}
+
 /// Depending on the built-in class, adds custom constructors and methods.
 fn make_special_builtin_methods(class_name: &TyName, _ctx: &Context) -> TokenStream {
     if class_name.godot_ty == "Array" {

godot-codegen/src/util.rs

@@ -4,7 +4,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use crate::api_parser::Enum;
+use crate::api_parser::{ClassConstant, Enum};
 use crate::special_cases::is_builtin_scalar;
 use crate::{Context, ModName, RustTy, TyName};
 use proc_macro2::{Ident, Literal, TokenStream};
@@ -106,6 +106,15 @@ pub fn make_enum_definition(enum_: &Enum) -> TokenStream {
     }
 }
 
+pub fn make_constant_definition(constant: &ClassConstant) -> TokenStream {
+    let ClassConstant { name, value } = constant;
+    let name = ident(name);
+
+    quote! {
+        pub const #name: i32 = #value;
+    }
+}
+
 fn make_enum_name(enum_name: &str) -> Ident {
     // TODO clean up enum name
 

godot-core/src/builtin/aabb.rs

@@ -0,0 +1,102 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use godot_ffi as sys;
+use sys::{ffi_methods, GodotFfi};
+
+use super::Vector3;
+
+/// Axis-aligned bounding box in 3D space.
+///
+/// `Aabb` consists of a position, a size, and several utility functions. It is typically used for
+/// fast overlap tests.
+///
+/// Currently most methods are only available through [`InnerAabb`](super::inner::InnerAabb).
+///
+/// The 2D counterpart to `Aabb` is [`Rect2`](super::Rect2).
+#[derive(Default, Copy, Clone, PartialEq, Debug)]
+#[repr(C)]
+pub struct Aabb {
+    pub position: Vector3,
+    pub size: Vector3,
+}
+
+impl Aabb {
+    /// Create a new `Aabb` from a position and a size.
+    ///
+    /// _Godot equivalent: `Aabb(Vector3 position, Vector3 size)`_
+    #[inline]
+    pub const fn new(position: Vector3, size: Vector3) -> Self {
+        Self { position, size }
+    }
+
+    /// Create a new `Aabb` with the first corner at `position` and opposite corner at `end`.
+    #[inline]
+    pub fn from_corners(position: Vector3, end: Vector3) -> Self {
+        Self {
+            position,
+            size: position + end,
+        }
+    }
+
+    /// The end of the `Aabb` calculated as `position + size`.
+    ///
+    /// _Godot equivalent: `Aabb.size` property_
+    #[inline]
+    pub fn end(&self) -> Vector3 {
+        self.position + self.size
+    }
+
+    /// Set size based on desired end-point.
+    ///
+    /// _Godot equivalent: `Aabb.size` property_
+    #[inline]
+    pub fn set_end(&mut self, end: Vector3) {
+        self.size = end - self.position
+    }
+
+    /// Returns `true` if the two `Aabb`s are approximately equal, by calling `is_equal_approx` on
+    /// `position` and `size`.
+    ///
+    /// _Godot equivalent: `Aabb.is_equal_approx()`_
+    #[inline]
+    pub fn is_equal_approx(&self, other: &Self) -> bool {
+        self.position.is_equal_approx(other.position) && self.size.is_equal_approx(other.size)
+    }
+
+    /* Add in when `Aabb::abs()` is implemented.
+    /// Assert that the size of the `Aabb` is not negative.
+    ///
+    /// Certain functions will fail to give a correct result if the size is negative.
+    #[inline]
+    pub fn assert_nonnegative(&self) {
+        assert!(
+            self.size.x >= 0.0 && self.size.y >= 0.0 && self.size.z >= 0.0,
+            "size {:?} is negative",
+            self.size
+        );
+    }
+    */
+}
+
+impl std::fmt::Display for Aabb {
+    /// Formats `Aabb` to match godot's display style.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use godot::prelude::*;
+    /// let aabb = Aabb::new(Vector3::new(0.0, 0.0, 0.0), Vector3::new(1.0, 1.0, 1.0));
+    /// assert_eq!(format!("{}", aabb), "[P: (0, 0, 0), S: (1, 1, 1)]");
+    /// ```
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        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,18 @@ 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 {
+    /// Formats `Color` to match godot's display style.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use godot::prelude::*;
+    /// let color = Color::from_rgba(1.0,1.0,1.0,1.0);
+    /// assert_eq!(format!("{}", color), "(1, 1, 1, 1)");
+    /// ```
+    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/mod.rs

@@ -35,6 +35,7 @@
 // Re-export macros.
 pub use crate::{array, dict, varray};
 
+pub use aabb::*;
 pub use array_inner::{Array, VariantArray};
 pub use basis::*;
 pub use color::*;
@@ -43,8 +44,11 @@ pub use math::*;
 pub use node_path::*;
 pub use others::*;
 pub use packed_array::*;
+pub use plane::*;
 pub use projection::*;
 pub use quaternion::*;
+pub use rect2::*;
+pub use rect2i::*;
 pub use rid::*;
 pub use string::*;
 pub use string_name::*;
@@ -84,15 +88,19 @@ mod array_inner;
 #[path = "dictionary.rs"]
 mod dictionary_inner;
 
+mod aabb;
 mod basis;
 mod color;
 mod glam_helpers;
 mod math;
 mod node_path;
 mod others;
 mod packed_array;
+mod plane;
 mod projection;
 mod quaternion;
+mod rect2;
+mod rect2i;
 mod rid;
 mod string;
 mod string_chars;
@@ -319,6 +327,17 @@ macro_rules! real {
     }};
 }
 
+/// The side of a [`Rect2`] or [`Rect2i`].
+///
+/// _Godot equivalent: `@GlobalScope.Side`_
+#[repr(C)]
+pub enum RectSide {
+    Left = 0,
+    Top = 1,
+    Right = 2,
+    Bottom = 3,
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
 /// Implementations of the `Export` trait for types where it can be done trivially.
@@ -352,7 +371,7 @@ mod export {
     impl_export_by_clone!(f32);
     impl_export_by_clone!(f64);
 
-    // impl_export_by_clone!(Aabb); // TODO uncomment once Aabb implements Clone
+    impl_export_by_clone!(Aabb);
     impl_export_by_clone!(Basis);
     impl_export_by_clone!(Color);
     impl_export_by_clone!(GodotString);
@@ -366,11 +385,11 @@ mod export {
     impl_export_by_clone!(PackedStringArray);
     impl_export_by_clone!(PackedVector2Array);
     impl_export_by_clone!(PackedVector3Array);
-    // impl_export_by_clone!(Plane); // TODO uncomment once Plane implements Clone
+    impl_export_by_clone!(Plane);
     impl_export_by_clone!(Projection);
     impl_export_by_clone!(Quaternion);
-    // impl_export_by_clone!(Rect2); // TODO uncomment once Rect2 implements Clone
-    // impl_export_by_clone!(Rect2i); // TODO uncomment once Rect2i implements Clone
+    impl_export_by_clone!(Rect2);
+    impl_export_by_clone!(Rect2i);
     impl_export_by_clone!(Rid);
     impl_export_by_clone!(StringName);
     impl_export_by_clone!(Transform2D);

godot-core/src/builtin/others.rs

@@ -6,36 +6,16 @@
 
 // Stub for various other built-in classes, which are currently incomplete, but whose types
 // are required for codegen
-use crate::builtin::{inner, StringName, Vector2};
+use crate::builtin::{inner, StringName};
 use crate::obj::{Gd, GodotClass};
 use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
 
 // TODO: Swap more inner math types with glam types
 // Note: ordered by enum ord in extension JSON
-impl_builtin_stub!(Rect2, OpaqueRect2);
-impl_builtin_stub!(Rect2i, OpaqueRect2i);
-impl_builtin_stub!(Plane, OpaquePlane);
-impl_builtin_stub!(Aabb, OpaqueAabb);
 impl_builtin_stub!(Callable, OpaqueCallable);
 impl_builtin_stub!(Signal, OpaqueSignal);
 
-#[repr(C)]
-struct InnerRect {
-    position: Vector2,
-    size: Vector2,
-}
-
-impl Rect2 {
-    pub fn size(self) -> Vector2 {
-        self.inner().size
-    }
-
-    fn inner(self) -> InnerRect {
-        unsafe { std::mem::transmute(self) }
-    }
-}
-
 impl Callable {
     pub fn from_object_method<T, S>(object: Gd<T>, method: S) -> Self
     where