Class icons definable by macro

Author: Paperback

godot-core/src/meta/mod.rs

@@ -102,4 +102,10 @@ pub(crate) use reexport_crate::*;
 /// Must not use meta facilities (e.g. `ClassId`) after this call.
 pub(crate) unsafe fn cleanup() {
     class_id::cleanup();
+
+    #[cfg(since_api = "4.4")]
+    {
+        let mut icons = crate::registry::class::global_icons_by_name();
+        *icons = std::collections::HashMap::new();
+    }
 }

godot-core/src/private.rs

@@ -186,6 +186,7 @@ pub trait You_forgot_the_attribute__godot_api {}
 
 pub struct ClassConfig {
     pub is_tool: bool,
+    pub icon: Option<&'static str>,
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------

godot-core/src/registry/class.rs

@@ -53,6 +53,14 @@ fn global_dyn_traits_by_typeid() -> GlobalGuard<'static, HashMap<any::TypeId, Ve
     lock_or_panic(&DYN_TRAITS_BY_TYPEID, "dyn traits")
 }
 
+#[cfg(since_api = "4.4")]
+pub(crate) fn global_icons_by_name(
+) -> GlobalGuard<'static, HashMap<ClassId, crate::builtin::GString>> {
+    static ICONS_BY_NAME: Global<HashMap<ClassId, crate::builtin::GString>> = Global::default();
+
+    lock_or_panic(&ICONS_BY_NAME, "icon strings (by name)")
+}
+
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 
 /// Represents a class which is currently loaded and retained in memory.
@@ -426,6 +434,7 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
             is_instantiable,
             reference_fn,
             unreference_fn,
+            icon,
         }) => {
             c.parent_class_name = Some(base_class_name);
             c.default_virtual_fn = default_get_virtual_fn;
@@ -466,6 +475,21 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
                 c.godot_params.is_runtime =
                     sys::conv::bool_to_sys(crate::private::is_class_runtime(is_tool));
             }
+
+            #[cfg(before_api = "4.4")]
+            let _ = icon; // mark used
+            #[cfg(since_api = "4.4")]
+            if let Some(icon_path) = icon {
+                // Convert to GString and store in global map to keep it alive for program lifetime.
+                let icon_gstring = crate::builtin::GString::from(icon_path);
+                let mut icon_map = global_icons_by_name();
+                icon_map.insert(c.class_name, icon_gstring);
+
+                let icon_ptr: sys::GDExtensionConstStringPtr =
+                    icon_map.get(&c.class_name).unwrap().string_sys();
+
+                c.godot_params.icon_path = icon_ptr;
+            }
         }
 
         PluginItem::InherentImpl(InherentImpl {

godot-core/src/registry/plugin.rs

@@ -195,6 +195,9 @@ pub struct Struct {
 
     /// Whether the class has a default constructor.
     pub(crate) is_instantiable: bool,
+
+    /// Icon path from `#[class(icon = EXPR)]`.
+    pub(crate) icon: Option<&'static str>,
 }
 
 impl Struct {
@@ -214,6 +217,7 @@ impl Struct {
             is_editor_plugin: false,
             is_internal: false,
             is_instantiable: false,
+            icon: None,
             // While Godot doesn't do anything with these callbacks for non-RefCounted classes, we can avoid instantiating them in Rust.
             reference_fn: refcounted.then_some(callbacks::reference::<T>),
             unreference_fn: refcounted.then_some(callbacks::unreference::<T>),
@@ -252,6 +256,12 @@ impl Struct {
         self
     }
 
+    #[cfg(since_api = "4.4")]
+    pub fn with_icon(mut self, icon: &'static str) -> Self {
+        self.icon = Some(icon);
+        self
+    }
+
     pub fn with_editor_plugin(mut self) -> Self {
         self.is_editor_plugin = true;
         self

godot-macros/src/class/derive_godot_class.rs

@@ -103,6 +103,7 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
         class_name,
         &struct_cfg.base_ty,
         struct_cfg.is_tool,
+        struct_cfg.icon.as_ref(),
         &fields.all_fields,
     );
 
@@ -146,6 +147,13 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
         modifiers.push(quote! { with_tool })
     }
 
+    // Handle icon separately since it takes an argument (can't use the modifiers pattern).
+    let icon_modifier = if let Some(icon) = &struct_cfg.icon {
+        quote! { .with_icon(#icon) }
+    } else {
+        TokenStream::new()
+    };
+
     // Declares a "funcs collection" struct that, for holds a constant for each #[func].
     // That constant maps the Rust name (constant ident) to the Godot registered name (string value).
     let funcs_collection_struct_name = format_funcs_collection_struct(class_name);
@@ -198,7 +206,7 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
         #struct_docs_registration
         ::godot::sys::plugin_add!(#prv::__GODOT_PLUGIN_REGISTRY; #prv::ClassPlugin::new::<#class_name>(
             #prv::PluginItem::Struct(
-                #prv::Struct::new::<#class_name>()#(.#modifiers())*
+                #prv::Struct::new::<#class_name>()#(.#modifiers())*#icon_modifier
             )
         ));
 
@@ -303,6 +311,7 @@ struct ClassAttributes {
     is_tool: bool,
     is_internal: bool,
     rename: Option<Ident>,
+    icon: Option<TokenStream>,
     deprecations: Vec<TokenStream>,
 }
 
@@ -421,6 +430,7 @@ fn make_user_class_impl(
     class_name: &Ident,
     trait_base_class: &Ident,
     is_tool: bool,
+    icon: Option<&TokenStream>,
     all_fields: &[Field],
 ) -> (TokenStream, bool) {
     #[cfg(feature = "codegen-full")]
@@ -480,12 +490,19 @@ fn make_user_class_impl(
         None
     };
 
+    let icon = if let Some(expr) = icon {
+        quote! { Some(#expr) }
+    } else {
+        quote! { None }
+    };
+
     let user_class_impl = quote! {
         impl ::godot::obj::UserClass for #class_name {
             #[doc(hidden)]
             fn __config() -> ::godot::private::ClassConfig {
                 ::godot::private::ClassConfig {
                     is_tool: #is_tool,
+                    icon: #icon,
                 }
             }
 
@@ -510,6 +527,7 @@ fn parse_struct_attributes(class: &venial::Struct) -> ParseResult<ClassAttribute
     let mut is_tool = false;
     let mut is_internal = false;
     let mut rename: Option<Ident> = None;
+    let mut icon: Option<TokenStream> = None;
     let mut deprecations = vec![];
 
     // #[class] attribute on struct
@@ -542,6 +560,11 @@ fn parse_struct_attributes(class: &venial::Struct) -> ParseResult<ClassAttribute
         // #[class(rename = NewName)]
         rename = parser.handle_ident("rename")?;
 
+        // #[class(icon = "PATH")]
+        if let Some(expr) = parser.handle_expr("icon")? {
+            icon = Some(expr);
+        }
+
         // #[class(internal)]
         // Named "internal" following Godot terminology: https://github.com/godotengine/godot-cpp/blob/master/include/godot_cpp/core/class_db.hpp#L327
         if parser.handle_alone("internal")? {
@@ -583,6 +606,7 @@ fn parse_struct_attributes(class: &venial::Struct) -> ParseResult<ClassAttribute
         is_tool,
         is_internal,
         rename,
+        icon,
         deprecations,
     })
 }

godot-macros/src/lib.rs

@@ -484,6 +484,17 @@ use crate::util::{bail, ident, KvParser};
 /// Even though this class is a `Node` and it has an init function, it still won't show up in the editor as a node you can add to a scene
 /// because we have added a `hidden` key to the class. This will also prevent it from showing up in documentation.
 ///
+/// ## Class Icon
+///
+/// You can set a class icon by providing a valid resource path using `#[class(icon = EXPR)]`.
+///
+/// ```
+/// # use godot::prelude::*;
+/// #[derive(GodotClass)]
+/// #[class(base=Node, init, icon = "res://icon.svg")]
+/// pub struct Foo {}
+/// ```
+///
 /// # Further field customization
 ///
 /// ## Fine-grained inference hints
@@ -561,11 +572,22 @@ use crate::util::{bail, ident, KvParser};
     alias = "export",
     alias = "tool",
     alias = "rename",
-    alias = "internal"
+    alias = "internal",
+    alias = "icon"
 )]
 #[proc_macro_derive(
     GodotClass,
-    attributes(class, base, hint, var, export, export_group, export_subgroup, init)
+    attributes(
+        class,
+        base,
+        hint,
+        var,
+        export,
+        export_group,
+        export_subgroup,
+        init,
+        icon
+    )
 )]
 pub fn derive_godot_class(input: TokenStream) -> TokenStream {
     translate(input, class::derive_godot_class)

itest/rust/src/register_tests/icon_test.rs

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * 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::prelude::*;
+
+use crate::framework::itest;
+
+const REF_COUNTED_ICON: &str = "res://icons/ref_counted_icon.svg";
+#[derive(GodotClass)]
+#[class(init, base=RefCounted, icon = REF_COUNTED_ICON)]
+struct ClassWithIconRefCounted {
+    base: Base<RefCounted>,
+}
+
+#[derive(GodotClass)]
+#[class(init, base=Node, icon = "INVALID!")]
+struct ClassWithInvalidIconNode {
+    base: Base<Node>,
+}
+
+#[derive(GodotClass)]
+#[class(init, base=Node, icon = "res://icons/node_icon.svg")]
+struct ClassWithIconNode {
+    base: Base<Node>,
+}
+
+#[derive(GodotClass)]
+#[class(init, tool, base=RefCounted, icon = "res://icons/tool_icon.svg")]
+struct ToolClassWithIcon {
+    base: Base<RefCounted>,
+}
+
+#[derive(GodotClass)]
+#[class(init, base=RefCounted, icon = "res://icons/another_icon.svg")]
+struct AnotherClassWithIcon {
+    base: Base<RefCounted>,
+}
+
+#[itest]
+fn class_with_icon_refcounted_registers() {
+    let instance = ClassWithIconRefCounted::new_gd();
+    assert!(instance.is_instance_valid());
+}
+
+#[itest]
+fn class_with_invalid_icon_refcounted_registers() {
+    let instance = ClassWithInvalidIconNode::new_alloc();
+    assert!(instance.is_instance_valid());
+}
+
+#[itest]
+fn class_with_icon_node_registers() {
+    let instance = ClassWithIconNode::new_alloc();
+    assert!(instance.is_instance_valid());
+    instance.free();
+}
+
+#[itest]
+fn tool_class_with_icon_registers() {
+    let instance = ToolClassWithIcon::new_gd();
+    assert!(instance.is_instance_valid());
+}
+
+#[itest]
+fn multiple_classes_with_different_icons_register() {
+    let instance1 = ClassWithIconRefCounted::new_gd();
+    let instance2 = AnotherClassWithIcon::new_gd();
+
+    assert!(instance1.is_instance_valid());
+    assert!(instance2.is_instance_valid());
+}

itest/rust/src/register_tests/mod.rs

@@ -14,6 +14,10 @@ mod multiple_impl_blocks_test;
 mod naming_tests;
 mod option_ffi_test;
 mod register_docs_test;
+
+#[cfg(since_api = "4.4")]
+mod icon_test;
+
 #[cfg(feature = "codegen-full")]
 mod rpc_test;
 mod var_test;