GdExtension class icon

- if no individual class icon is set, it will act as an extension wide default
- if you set an individual class icon, it use that INSTEAD, via #[class(icon = PATH)]
- the GdExtension [icons] declarations will not do anything if you use #[gdextension(icon = PATH])
- #[gdextension] generates ExtensionConfig which is very similar to ClassConfig but just holds the icon path

Author: Paperback

godot-core/src/init/mod.rs

@@ -27,6 +27,22 @@ struct InitUserData {
     main_loop_callbacks: sys::GDExtensionMainLoopCallbacks,
 }
 
+#[derive(Copy, Clone, Default)]
+pub struct ExtensionConfig {
+    pub icon: Option<&'static str>,
+}
+
+impl ExtensionConfig {
+    pub const fn new() -> Self {
+        Self { icon: None }
+    }
+
+    pub const fn with_icon(mut self, icon: &'static str) -> Self {
+        self.icon = Some(icon);
+        self
+    }
+}
+
 #[cfg(since_api = "4.5")]
 unsafe extern "C" fn startup_func<E: ExtensionLibrary>() {
     E::on_stage_init(InitStage::MainLoop);
@@ -117,6 +133,11 @@ pub unsafe fn __gdext_load_library<E: ExtensionLibrary>(
     is_success.unwrap_or(0)
 }
 
+/// This contains metadata declared through [`#[gdextension]`](attr.gdextension.html)
+pub fn extension_config() -> ExtensionConfig {
+    crate::private::extension_config()
+}
+
 static LEVEL_SERVERS_CORE_LOADED: AtomicBool = AtomicBool::new(false);
 
 unsafe extern "C" fn ffi_initialize_layer<E: ExtensionLibrary>(
@@ -289,6 +310,18 @@ fn gdext_on_level_deinit(level: InitLevel) {
 /// Note that this only changes the name. You cannot provide your own function -- use the [`on_level_init()`][ExtensionLibrary::on_level_init]
 /// hook for custom startup logic.
 ///
+/// # Extension metadata
+/// Provide additional metadata directly on the attribute. For example, on Godot 4.4+ you can assign the icon shown in the editor's
+/// extension list like so:
+/// ```no_run
+/// # use godot::init::*;
+/// struct MyExtension;
+///
+/// #[gdextension(icon = "res://addons/my_extension/icon.svg")]
+/// unsafe impl ExtensionLibrary for MyExtension {}
+/// ```
+/// The values provided here are exposed via [`extension_config()`] for tooling and build scripts.
+///
 /// # Availability of Godot APIs during init and deinit
 // Init order: see also special_cases.rs > classify_codegen_level().
 /// Godot loads functionality gradually during its startup routines, and unloads it during shutdown. As a result, Godot classes are only

godot-core/src/private.rs

@@ -57,6 +57,7 @@ static ERROR_PRINT_LEVEL: atomic::AtomicU8 = atomic::AtomicU8::new(2);
 sys::plugin_registry!(pub __GODOT_PLUGIN_REGISTRY: ClassPlugin);
 #[cfg(all(since_api = "4.3", feature = "register-docs"))]
 sys::plugin_registry!(pub __GODOT_DOCS_REGISTRY: DocsPlugin);
+sys::plugin_registry!(pub __GODOT_EXTENSION_CONFIG_REGISTRY: crate::init::ExtensionConfig);
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
 // Call error handling
@@ -151,6 +152,11 @@ pub(crate) fn iterate_plugins(mut visitor: impl FnMut(&ClassPlugin)) {
     sys::plugin_foreach!(__GODOT_PLUGIN_REGISTRY; visitor);
 }
 
+pub(crate) fn extension_config() -> crate::init::ExtensionConfig {
+    let guard = __GODOT_EXTENSION_CONFIG_REGISTRY.lock().unwrap();
+    guard.last().copied().unwrap_or_default()
+}
+
 #[cfg(all(since_api = "4.3", feature = "register-docs"))]
 pub(crate) fn iterate_docs_plugins(mut visitor: impl FnMut(&DocsPlugin)) {
     sys::plugin_foreach!(__GODOT_DOCS_REGISTRY; visitor);

godot-core/src/registry/class.rs

@@ -588,6 +588,23 @@ fn register_class_raw(mut info: ClassRegistrationInfo) {
         info.godot_params.get_virtual_func = info.user_virtual_fn.or(info.default_virtual_fn);
     }
 
+    // If no class-level icon was set, use the extension-level icon as fallback (if available)
+    #[cfg(since_api = "4.4")]
+    if info.godot_params.icon_path.is_null() {
+        if let Some(extension_icon) = crate::init::extension_config().icon {
+            let icon_gstring = crate::builtin::GString::from(extension_icon);
+
+            // SAFETY: The GString is stored in a static HashMap, so the pointer remains valid
+            // even after the lock guard is dropped. We must retrieve the pointer while holding
+            // the lock to ensure the HashMap isn't being modified concurrently.
+            let mut icon_map = global_icon_strings();
+            let icon_ptr = icon_gstring.string_sys() as sys::GDExtensionConstStringPtr;
+            icon_map.insert(class_name, icon_gstring);
+
+            info.godot_params.icon_path = icon_ptr;
+        }
+    }
+
     // The explicit () type notifies us if Godot API ever adds a return type.
     let registration_failed = unsafe {
         // Try to register class...

godot-macros/src/gdextension.rs

@@ -29,6 +29,7 @@ pub fn attribute_gdextension(item: venial::Item) -> ParseResult<TokenStream> {
     let mut parser = KvParser::parse_required(&drained_attributes, "gdextension", &impl_decl)?;
     let entry_point = parser.handle_ident("entry_point")?;
     let entry_symbol = parser.handle_ident("entry_symbol")?;
+    let icon = parser.handle_expr("icon")?;
     parser.finish()?;
 
     if entry_point.is_some() && entry_symbol.is_some() {
@@ -50,7 +51,21 @@ pub fn attribute_gdextension(item: venial::Item) -> ParseResult<TokenStream> {
 
     let impl_ty = &impl_decl.self_ty;
 
+    let mut modifiers = Vec::new();
+    if icon.is_some() {
+        let icon_expr = icon.unwrap();
+        modifiers.push(quote! { with_icon(#icon_expr) });
+    }
+
+    let extension_config_registration = quote! {
+        ::godot::sys::plugin_add!(
+            ::godot::private::__GODOT_EXTENSION_CONFIG_REGISTRY;
+            ::godot::init::ExtensionConfig::new()#( .#modifiers )*
+        );
+    };
+
     Ok(quote! {
+        #extension_config_registration
         #deprecation
         #impl_decl