Add 32-bit architecture support

Enable cross-compilation to 32-bit targets (e.g., wasm) by addressing
bindgen layout test incompatibilities.

Problem:
Bindgen generates compile-time struct size/alignment assertions based on
the host architecture (64-bit). When cross-compiling to 32-bit, these
assertions fail because pointer sizes differ (8 bytes vs 4 bytes).

Solution:
- For `api-custom` mode: disable layout_tests in bindgen configuration
- For prebuilt mode: strip layout assertion blocks only when targeting
  32-bit (CARGO_CFG_TARGET_POINTER_WIDTH == "32")

Native 64-bit builds retain all safety checks intact. The assertions are
only removed for 32-bit targets where they would be incorrect anyway
(validating 64-bit sizes against 32-bit structs).

Author: ufoot

godot-bindings/src/header_gen.rs

@@ -23,10 +23,22 @@ pub(crate) fn generate_rust_binding(in_h_path: &Path, out_rs_path: &Path) {
     // If you have an idea to address this without too invasive changes, please comment on that issue.
     let cargo_cfg = bindgen::CargoCallbacks::new().rerun_on_header_files(false);
 
+    // Only disable layout tests when cross-compiling between different pointer widths.
+    // Layout tests are generated based on the host architecture but validated on the target,
+    // which causes failures when cross-compiling (e.g., from 64-bit host to 32-bit target)
+    // because struct sizes differ. See: https://github.com/godot-rust/gdext/issues/347.
+    let host_pointer_width = std::mem::size_of::<usize>() * 8;
+    let target_pointer_width: usize = env::var("CARGO_CFG_TARGET_POINTER_WIDTH")
+        .ok()
+        .and_then(|s| s.parse().ok())
+        .unwrap_or(host_pointer_width);
+    let enable_layout_tests = host_pointer_width == target_pointer_width;
+
     let builder = bindgen::Builder::default()
         .header(c_header_path)
         .parse_callbacks(Box::new(cargo_cfg))
         .prepend_enum_name(false)
+        .layout_tests(enable_layout_tests)
         // Bindgen can generate wrong size checks for types defined as `__attribute__((aligned(__alignof__(struct {...}))))`,
         // which is how clang defines max_align_t: https://clang.llvm.org/doxygen/____stddef__max__align__t_8h_source.html.
         // Size checks seems to be fine on all the targets but `wasm32-unknown-emscripten`, disallowing web builds.

godot-bindings/src/lib.rs

@@ -130,11 +130,87 @@ mod depend_on_prebuilt {
         watch.record("write_header_h");
 
         let rs_contents = prebuilt::load_gdextension_header_rs();
-        std::fs::write(rs_path, rs_contents.as_ref())
+
+        // Prebuilt bindings are generated for 64-bit. When targeting 32-bit, we must strip
+        // the layout assertions since they validate 64-bit struct sizes which don't match.
+        // For native 64-bit builds, we keep the safety checks intact.
+        // See: https://github.com/godot-rust/gdext/issues/347
+        let target_pointer_width = std::env::var("CARGO_CFG_TARGET_POINTER_WIDTH")
+            .expect("CARGO_CFG_TARGET_POINTER_WIDTH not set");
+        let rs_contents = if target_pointer_width == "32" {
+            strip_bindgen_layout_tests(rs_contents.as_ref())
+        } else {
+            rs_contents.to_string()
+        };
+
+        std::fs::write(rs_path, rs_contents)
             .unwrap_or_else(|e| panic!("failed to write gdextension_interface.rs: {e}"));
         watch.record("write_header_rs");
     }
 
+    /// Removes bindgen-generated layout test assertion blocks from the source code.
+    ///
+    /// Bindgen generates compile-time assertions in blocks like:
+    /// ```ignore
+    /// const _: () = {
+    ///     ["Size of SomeStruct"][::std::mem::size_of::<SomeStruct>() - 48usize];
+    ///     ["Alignment of SomeStruct"][::std::mem::align_of::<SomeStruct>() - 8usize];
+    /// };
+    /// ```
+    ///
+    /// These cause compile-time errors when cross-compiling between 32-bit and 64-bit targets
+    /// because struct sizes differ based on pointer width.
+    /// See: https://github.com/godot-rust/gdext/issues/347
+    fn strip_bindgen_layout_tests(source: &str) -> String {
+        let mut result = String::with_capacity(source.len());
+        let mut in_const_block = false;
+        let mut brace_depth = 0;
+
+        for line in source.lines() {
+            let trimmed = line.trim();
+
+            // Detect start of a const assertion block.
+            // Pattern: `const _: () = {` or with #[allow(...)] attributes before.
+            if !in_const_block && trimmed.starts_with("const _: () = {") {
+                in_const_block = true;
+                brace_depth = 1;
+                continue;
+            }
+
+            // Skip lines with #[allow(...)] that precede const blocks.
+            if !in_const_block
+                && trimmed.starts_with("#[allow(")
+                && trimmed.contains("clippy::unnecessary_operation")
+            {
+                continue;
+            }
+
+            if in_const_block {
+                // Track brace depth to find the end of the block.
+                for ch in trimmed.chars() {
+                    match ch {
+                        '{' => brace_depth += 1,
+                        '}' => {
+                            brace_depth -= 1;
+                            if brace_depth == 0 {
+                                in_const_block = false;
+                                break;
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+                continue; // Skip all lines inside the const block.
+            }
+
+            // Keep all other lines.
+            result.push_str(line);
+            result.push('\n');
+        }
+
+        result
+    }
+
     pub(crate) fn get_godot_version() -> GodotVersion {
         let version: Vec<&str> = prebuilt::GODOT_VERSION_STRING
             .split('.')