..
    #[var(
        usage_flags = [EDITOR],
        hint = TOOL_BUTTON,
        hint_string = "Win after achieving given score."
    )]
    win_at_score: Callable,

    #[var(
        usage_flags = [EDITOR],
        hint = TOOL_BUTTON,
        hint_string = "Spawn exit after achieving given score."
    )]
    spawn_exit: Callable,
..

    fn init(base: Base<Self::Base>) -> Self {
        let that = base.to_init_gd();
        let win_at_score =
            Self::create_win_condition_callable(&that, "WinAtScore", &["WinAtScore", "SpawnExit"]);
        let spawn_exit =
            Self::create_win_condition_callable(&that, "SpawnExit", &["WinAtScore", "SpawnExit"]);
        Self {
            bounds: Default::default(),
            current_score: Default::default(),
            level_stats: Default::default(),
            spawn_exit,
            win_at_score,
            base,
        }
    }

    ...
    #[export_group(name = "Triggers")]
    /// Creates new spawner.
    #[var(
        usage_flags = [EDITOR],
        hint = TOOL_BUTTON,
        hint_string = "Create new spawner"
    )]
    #[init(val = Callable::invalid())]
    create_spawner: Callable,
    ..

    fn on_notification(&mut self, what: godot::classes::notify::NodeNotification) {
        match what {
            ...
            NodeNotification::ENTER_TREE | NodeNotification::EXTENSION_RELOADED => {
                if !Engine::singleton().is_editor_hint() {
                    return;
                }
                let mut obj = self.to_gd();
                self.create_spawner = Callable::from_fn("Create the spawner", move |_args| {
                    let mut spawner = BallSpawner::new_alloc();
                    obj.add_child(&spawner);

                    let owner = obj.get_tree().unwrap().get_edited_scene_root().unwrap();
                    spawner.set_owner(&owner);
                });
            }
        }

#[derive(GodotClass)]
#[class(init, tool, base = Node)]
struct MyClass {
    // A var. Doesn't autogenerate any Callable, leaving it up to the user.
    #[export_tool_button(name = "My very cool tool button", icon = "Add")]
    manual_tool_button: Callable,

    // Runs some static method.
    #[export_tool_button(fn=some_fn, icon="3D", name="run static fn")]
    run_static_fn: Callable,

    // Run fn with &mut dyn Trait receiver
    #[export_tool_button(fn_self=dyn_fn_one, icon="2DNodes", name="Run dyn fn")]
    dyn_fn1: Callable,

    // Run fn with &mut dyn Trait2 receiver
    #[export_tool_button(fn_self=dyn_fn_two, icon="2DNodes", name="Run dyn fn 2")]
    dyn_fn2: Callable,

    // Run Self::method
    #[export_tool_button(fn_self=Self::my_fn, icon="Blend", name="run Self::fn")]
    fn_myself: Callable,

    // Run fn<T:...>(me: &mut T) {...}
    #[export_tool_button(fn_self=generic_fn, icon="Blend", name="run generic fn")]
    fn_generic: Callable,

    // Ol' reliable `func`.
    #[export_tool_button(method = "my_method", name = "run method fn")]
    fn_method: Callable,

    base: Base<Node>,
}

fn some_fn() {
    godot_print!("hello from some fn!");
}

fn dyn_fn_one(_this: &mut dyn ExampleTrait) {
    godot_print!("Hello from other fn!");
}

fn dyn_fn_two(_this: &mut dyn ExampleTrait2) {
    godot_print!("Hello from other fn2!");
}

pub trait ExampleTrait2 {}

pub trait ExampleTrait {}

impl ExampleTrait for MyClass {}

impl ExampleTrait2 for MyClass {}

fn generic_fn<T>(something: &mut T)
where
    T: GodotClass<Base = Node> + Inherits<Node> + WithBaseField
{
    let mut node = Node::new_alloc();
    something.base_mut().add_child(&node);
    let owner = something.base().get_tree().unwrap().get_edited_scene_root().unwrap();
    node.set_owner(&owner);
}


#[godot_api]
impl MyClass {
    fn my_fn(&mut self) {
        godot_print!("hello from my fn!");
    }

    #[func(gd_self)]
    fn my_method(this: Gd<Self>) {
        godot_print!("Hello with {this}!");
    }
}

#[godot_api]
impl INode for MyClass {
    fn on_notification(&mut self, what: NodeNotification) {
        match what {
            NodeNotification::ENTER_TREE | NodeNotification::EXTENSION_RELOADED => {
                self.manual_tool_button = Callable::from_fn("manual fn", |_| {
                    godot_print!("hello from manual tool button!")
                });
            }
            _ => {}
        }
    }
}