add support for nothreads build to single threaded init

Author: PgBiel

godot-core/Cargo.toml

@@ -21,6 +21,7 @@ codegen-lazy-fptrs = [
 double-precision = ["godot-codegen/double-precision"]
 experimental-godot-api = ["godot-codegen/experimental-godot-api"]
 experimental-threads = ["godot-ffi/experimental-threads"]
+experimental-wasm-nothreads = ["godot-ffi/experimental-wasm-nothreads"]
 debug-log = ["godot-ffi/debug-log"]
 trace = []
 

godot-ffi/Cargo.toml

@@ -15,6 +15,7 @@ codegen-rustfmt = ["godot-codegen/codegen-rustfmt"]
 codegen-lazy-fptrs = ["godot-codegen/codegen-lazy-fptrs"]
 experimental-godot-api = ["godot-codegen/experimental-godot-api"]
 experimental-threads = []
+experimental-wasm-nothreads = []
 debug-log = []
 
 api-custom = ["godot-bindings/api-custom"]

godot-ffi/src/binding/single_threaded.rs

@@ -10,13 +10,27 @@
 //! If used from different threads then there will be runtime errors in debug mode and UB in release mode.
 
 use std::cell::Cell;
+
+#[cfg(any(
+    not(target_family = "wasm"),
+    not(feature = "experimental-wasm-nothreads")
+))]
 use std::thread::ThreadId;
 
 use super::GodotBinding;
 use crate::ManualInitCell;
 
 pub(super) struct BindingStorage {
+    // No threading when linking against Godot with a nothreads Wasm build.
+    // Therefore, we just need to check if the bindings were initialized, as all accesses are from the main thread.
+    #[cfg(all(target_family = "wasm", feature = "experimental-wasm-nothreads"))]
+    initialized: Cell<bool>,
+
     // Is used in to check that we've been called from the right thread, so must be thread-safe to access.
+    #[cfg(any(
+        not(target_family = "wasm"),
+        not(feature = "experimental-wasm-nothreads")
+    ))]
     main_thread_id: Cell<Option<ThreadId>>,
     binding: ManualInitCell<GodotBinding>,
 }
@@ -30,6 +44,13 @@ impl BindingStorage {
     #[inline(always)]
     unsafe fn storage() -> &'static Self {
         static BINDING: BindingStorage = BindingStorage {
+            #[cfg(all(target_family = "wasm", feature = "experimental-wasm-nothreads"))]
+            initialized: Cell::new(false),
+
+            #[cfg(any(
+                not(target_family = "wasm"),
+                not(feature = "experimental-wasm-nothreads")
+            ))]
             main_thread_id: Cell::new(None),
             binding: ManualInitCell::new(),
         };
@@ -49,9 +70,24 @@ impl BindingStorage {
         // in which case we can tell that the storage has been initialized, and we don't access `binding`.
         let storage = unsafe { Self::storage() };
 
-        storage
-            .main_thread_id
-            .set(Some(std::thread::current().id()));
+        // 'std::thread::current()' fails when linking to a Godot build without threads. When this feature is enabled,
+        // we assume it is impossible to have multi-threading, so checking if we are in the main thread is not needed.
+        // Therefore, we assign a bogus value for the thread ID instead, so we can still check for prior initialization
+        // through this field later.
+        #[cfg(all(target_family = "wasm", feature = "experimental-wasm-nothreads"))]
+        {
+            storage.initialized.set(true);
+        }
+
+        #[cfg(any(
+            not(target_family = "wasm"),
+            not(feature = "experimental-wasm-nothreads")
+        ))]
+        {
+            storage
+                .main_thread_id
+                .set(Some(std::thread::current().id()));
+        }
 
         // SAFETY: We are the first thread to set this binding (possibly after deinitialize), as otherwise the above set() would fail and
         // return early. We also know initialize() is not called concurrently with anything else that can call another method on the binding,
@@ -70,12 +106,27 @@ impl BindingStorage {
         // SAFETY: We only call this once no other operations happen anymore, i.e. no other access to the binding.
         let storage = unsafe { Self::storage() };
 
-        storage
-            .main_thread_id
-            .get()
-            .expect("deinitialize without prior initialize");
+        #[cfg(all(target_family = "wasm", feature = "experimental-wasm-nothreads"))]
+        {
+            if !storage.initialized.get() {
+                panic!("deinitialize without prior initialize");
+            }
 
-        storage.main_thread_id.set(None);
+            storage.initialized.set(false);
+        }
+
+        #[cfg(any(
+            not(target_family = "wasm"),
+            not(feature = "experimental-wasm-nothreads")
+        ))]
+        {
+            storage
+                .main_thread_id
+                .get()
+                .expect("deinitialize without prior initialize");
+
+            storage.main_thread_id.set(None);
+        }
 
         // SAFETY: We are the only thread that can access the binding, and we know that it's initialized.
         unsafe {
@@ -92,7 +143,16 @@ impl BindingStorage {
     pub unsafe fn get_binding_unchecked() -> &'static GodotBinding {
         let storage = Self::storage();
 
-        if cfg!(debug_assertions) {
+        // We only check if we are in the main thread in debug builds if we aren't building for a non-threaded Godot build,
+        // since we could otherwise assume there won't be multi-threading.
+        #[cfg(all(
+            debug_assertions,
+            any(
+                not(target_family = "wasm"),
+                not(feature = "experimental-wasm-nothreads")
+            )
+        ))]
+        {
             let main_thread_id = storage.main_thread_id.get().expect(
                 "Godot engine not available; make sure you are not calling it from unit/doc tests",
             );
@@ -111,6 +171,14 @@ impl BindingStorage {
     pub fn is_initialized() -> bool {
         // SAFETY: We don't access the binding.
         let storage = unsafe { Self::storage() };
+
+        #[cfg(all(target_family = "wasm", feature = "experimental-wasm-nothreads"))]
+        return storage.initialized.get();
+
+        #[cfg(any(
+            not(target_family = "wasm"),
+            not(feature = "experimental-wasm-nothreads")
+        ))]
         storage.main_thread_id.get().is_some()
     }
 }

godot/Cargo.toml

@@ -18,6 +18,7 @@ double-precision = ["godot-core/double-precision"]
 experimental-godot-api = ["godot-core/experimental-godot-api"]
 experimental-threads = ["godot-core/experimental-threads"]
 experimental-wasm = []
+experimental-wasm-nothreads = ["godot-core/experimental-wasm-nothreads"]
 codegen-rustfmt = ["godot-core/codegen-rustfmt"]
 lazy-function-tables = ["godot-core/codegen-lazy-fptrs"]
 serde = ["godot-core/serde"]

godot/src/lib.rs

@@ -68,7 +68,7 @@
 //! * **`api-custom`**
 //!
 //!   Sets the [**API level**](https://godot-rust.github.io/book/toolchain/godot-version.html) to the specified Godot version,
-//!   or a custom-built local binary.  
+//!   or a custom-built local binary.
 //!   You can use at most one `api-*` feature. If absent, the current Godot minor version is used, with patch level 0.<br><br>
 //!
 //! * **`double-precision`**
@@ -124,6 +124,12 @@ pub mod __docs;
 #[cfg(all(feature = "lazy-function-tables", feature = "experimental-threads"))]
 compile_error!("Thread safety for lazy function pointers is not yet implemented.");
 
+#[cfg(all(
+    feature = "experimental-wasm-nothreads",
+    feature = "experimental-threads"
+))]
+compile_error!("Cannot use 'experimental-threads' with a nothreads Wasm build yet.");
+
 #[cfg(all(target_family = "wasm", not(feature = "experimental-wasm")))]
 compile_error!("Must opt-in using `experimental-wasm` Cargo feature; keep in mind that this is work in progress");