Make UserData pointer-packing actually sound

physx-sys/pxbind/src/consumer.rs

@@ -726,6 +726,11 @@ pub enum Builtin {
     Mat33,
     Mat34,
     Mat44,
+    // on the C++ side, `void*`, but we want to be able to pack arbitrary data into the space
+    // available so we treat it as a separate type so we can do that properly in the Rust side
+    UserData,
+    // same as above but `const void*
+    ConstUserData,
 }
 
 impl Builtin {
@@ -758,6 +763,8 @@ impl Builtin {
             Self::Mat34V => "glam::Affine3A",
             Self::Mat34 => "Affine",
             Self::Mat44V | Self::Mat44 => "PxMat44",
+            Self::UserData => "UserData",
+            Self::ConstUserData => "ConstUserData",
         }
     }
 
@@ -793,6 +800,8 @@ impl Builtin {
             Self::Mat34 => "physx_Mat34_Pod",
             Self::Mat44V => "physx_Mat44V_Pod",
             Self::Mat44 => "physx_PxMat44_Pod",
+            Self::UserData => "void*",
+            Self::ConstUserData => "void const*",
         }
     }
 
@@ -828,6 +837,8 @@ impl Builtin {
             Self::Mat34 => "physx::PxMat34",
             Self::Mat44V => "physx::PxMat44V",
             Self::Mat44 => "physx::PxMat44",
+            Self::UserData => "void*",
+            Self::ConstUserData => "void const*",
         }
     }
 
@@ -847,6 +858,8 @@ impl Builtin {
                 | Self::UInt
                 | Self::Long
                 | Self::ULong
+                | Self::UserData
+                | Self::ConstUserData
         )
     }
 }

physx-sys/pxbind/src/consumer/functions.rs

@@ -1,4 +1,4 @@
-use super::{Comment, Item, Method, QualType, TemplateArg};
+use super::{Builtin, Comment, Item, Method, QualType, TemplateArg};
 use crate::Node;
 use anyhow::Context as _;
 use std::borrow::Cow;
@@ -197,14 +197,22 @@ impl<'ast> super::AstConsumer<'ast> {
                 .name
                 .as_deref()
                 .map_or_else(|| format!("anon_param{i}").into(), Cow::Borrowed);
-            let kind = self
-                .parse_type(&param.kind, template_types)
-                .with_context(|| {
-                    format!(
-                        "failed to parse parameter '{pname} ({})' for function '{name}'",
-                        param.kind.qual_type,
-                    )
-                })?;
+
+            let kind = if param.name.as_ref().map_or(false, |name| name == "userData") {
+                if param.kind.qual_type.contains("const") {
+                    QualType::Builtin(Builtin::ConstUserData)
+                } else {
+                    QualType::Builtin(Builtin::UserData)
+                }
+            } else {
+                self.parse_type(&param.kind, template_types)
+                    .with_context(|| {
+                        format!(
+                            "failed to parse parameter '{pname} ({})' for function '{name}'",
+                            param.kind.qual_type,
+                        )
+                    })?
+            };
 
             func.params.push(Param { name: pname, kind });
         }
@@ -229,7 +237,21 @@ impl<'ast> super::AstConsumer<'ast> {
                 .with_context(|| format!("function signature for '{name}' doesn't have a '('"))?;
 
             let ret = sig[..open_ind].trim();
-            if ret != "void" {
+            if name.contains("getUserData") {
+                if ret == "void*" || ret == "void *" {
+                    func.ret = Some(QualType::Builtin(Builtin::UserData));
+                } else {
+                    log::warn!(
+                        "found function with name containing getUserData that had unexpected return type: {ret}"
+                    );
+                    if ret != "void" {
+                        func.ret =
+                            Some(self.parse_type(ret, template_types).with_context(|| {
+                                format!("failed to parse return type for '{name}'")
+                            })?);
+                    }
+                }
+            } else if ret != "void" {
                 func.ret = Some(
                     self.parse_type(ret, template_types)
                         .with_context(|| format!("failed to parse return type for '{name}'"))?,

physx-sys/pxbind/src/consumer/record.rs

@@ -713,9 +713,17 @@ impl<'ast> super::AstConsumer<'ast> {
                             continue;
                         }
 
-                        let kind = self
-                            .parse_type(kind, template_types)
-                            .with_context(|| format!("failed to parse type for {rname}::{name}"))?;
+                        let kind = if name == "userData" || name == "mUserData" {
+                            if kind.qual_type.contains("const") {
+                                QualType::Builtin(Builtin::ConstUserData)
+                            } else {
+                                QualType::Builtin(Builtin::UserData)
+                            }
+                        } else {
+                            self.parse_type(kind, template_types).with_context(|| {
+                                format!("failed to parse type for {rname}::{name}")
+                            })?
+                        };
 
                         // if matches!(&kind, QualType::FunctionPointer) {
                         //     continue;