q 0.1.1

Q is a Rust GDExtension crate for Godot, offering a Game Manager, Music Manager, Bevy ECS, and Tokio-powered multi-threading. It simplifies and enhances game development with efficient tools and scalable performance.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::debug_print;
use crate::find_game_manager;
use crate::manager::game_manager::GameManager;
use godot::classes::{CanvasLayer, ICanvasLayer, IControl};
use godot::prelude::*;

#[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
use crate::platform::browser::GodotBrowser;

#[derive(GodotClass)]
#[class(base = CanvasLayer)]
pub struct BrowserManager {
    base: Base<CanvasLayer>,

    game_manager: Option<Gd<GameManager>>,

    #[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
    browser: Option<Gd<GodotBrowser>>,
}

#[godot_api]
impl ICanvasLayer for BrowserManager {
    fn init(base: Base<Self::Base>) -> Self {
        Self {
            base,
            #[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
            browser: Some(Gd::from_init_fn(GodotBrowser::init)),

            game_manager: None,
        }
    }

    fn ready(&mut self) {
        find_game_manager!(self);
        #[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
        {
            // use raw_window_handle::HasWindowHandle;
            let browser_clone = self.browser.clone();
            {
                let mut base = self.base_mut();
                base.add_child(
                    &browser_clone
                        .expect("failed to updoot browser")
                        .upcast::<Node>(),
                );
                base.set_follow_viewport(true);
            }

            if let Some(browser_gd) = &self.browser {
                let browser = browser_gd.bind();
                if browser.is_initialized() {
                    godot_print!("[BrowserManager] Browser initialized.");
                } else {
                    godot_error!("[BrowserManager] WebView failed to initialize.");
                }
            }
        }

        #[cfg(target_arch = "wasm32")]
        {
            godot_print!("[BrowserManager] Running on WASM. JavaScript FFI will be used.");
        }

        {
            let base = self.base_mut();
            if let Some(tree) = base.get_tree()
                && let Some(mut root) = tree.get_root()
            {
                let callable = Callable::from_object_method(
                    &base.clone().upcast::<Node>(),
                    "on_window_resize",
                );

                let error = root.connect("size_changed", &callable);
                if error != godot::global::Error::OK {
                    godot_error!(
                        "[BrowserManager] Failed to connect root size_changed: {:?}",
                        error
                    );
                } else {
                    godot_print!(
                        "[BrowserManager] Connected root size_changed to on_window_resize."
                    );
                }
            }
        }
    }
}

#[godot_api]
impl BrowserManager {
    #[func]
    pub fn on_window_resize(&self) {
        godot_print!("[BrowserManager] Browser Event Trigger...");

        #[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
        {
            if let Some(ref browser) = self.browser {
                godot_print!("[BrowserManager] Resizing browser after window resize event.");
                browser.bind().resize();
            }
        }
    }

    #[func]
    pub fn open_url(&self, url: GString) {
        #[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
        {
            if let Some(ref browser) = self.browser {
                browser.bind().open_url(url.clone());
            } else {
                godot_warn!("[BrowserManager] Browser not initialized. Cannot open URL.");
            }
        }

        #[cfg(target_arch = "wasm32")]
        {
            godot_print!("[BrowserManager] Opening URL via JavaScript FFI: {}", url);
        }
    }
}