physx-sys 0.7.0

// Automatically generated by pxbind
#include "PxPhysicsAPI.h"
using namespace physx;

#define unsafe_offsetof(st, m) ((size_t) ( (char *)&((st *)(0))->m - (char *)0 ))
#include "structgen.hpp"
int main() {
PodStructGen structGen;
structGen.passThroughC("struct physx_PxAllocatorCallback_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxAssertHandler_Pod {\n    void* vtable_;\n};\n");
struct physx_PxVec3_Pod: public physx::PxVec3 {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVec3_Pod", "PxVec3");
        structGen.addField("float x", "x", "f32",sizeof(float), unsafe_offsetof(physx_PxVec3_Pod, x));
        structGen.addField("float y", "y", "f32",sizeof(float), unsafe_offsetof(physx_PxVec3_Pod, y));
        structGen.addField("float z", "z", "f32",sizeof(float), unsafe_offsetof(physx_PxVec3_Pod, z));
        structGen.endStruct(sizeof(physx::PxVec3));
    }
};
physx_PxVec3_Pod::dumpLayout(structGen);

struct physx_PxQuat_Pod: public physx::PxQuat {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxQuat_Pod", "PxQuat");
        structGen.addField("float x", "x", "f32",sizeof(float), unsafe_offsetof(physx_PxQuat_Pod, x));
        structGen.addField("float y", "y", "f32",sizeof(float), unsafe_offsetof(physx_PxQuat_Pod, y));
        structGen.addField("float z", "z", "f32",sizeof(float), unsafe_offsetof(physx_PxQuat_Pod, z));
        structGen.addField("float w", "w", "f32",sizeof(float), unsafe_offsetof(physx_PxQuat_Pod, w));
        structGen.endStruct(sizeof(physx::PxQuat));
    }
};
physx_PxQuat_Pod::dumpLayout(structGen);

struct physx_PxMat33_Pod: public physx::PxMat33 {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxMat33_Pod", "PxMat33");
        structGen.addField("physx_PxVec3_Pod column0", "column0", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxMat33_Pod, column0));
        structGen.addField("physx_PxVec3_Pod column1", "column1", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxMat33_Pod, column1));
        structGen.addField("physx_PxVec3_Pod column2", "column2", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxMat33_Pod, column2));
        structGen.endStruct(sizeof(physx::PxMat33));
    }
};
physx_PxMat33_Pod::dumpLayout(structGen);

struct physx_PxPlane_Pod: public physx::PxPlane {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxPlane_Pod", "PxPlane");
        structGen.addField("physx_PxVec3_Pod n", "n", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxPlane_Pod, n));
        structGen.addField("float d", "d", "f32",sizeof(float), unsafe_offsetof(physx_PxPlane_Pod, d));
        structGen.endStruct(sizeof(physx::PxPlane));
    }
};
physx_PxPlane_Pod::dumpLayout(structGen);

struct physx_PxTransform_Pod: public physx::PxTransform {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxTransform_Pod", "PxTransform");
        structGen.addField("physx_PxQuat_Pod q", "q", "PxQuat",sizeof(physx::PxQuat), unsafe_offsetof(physx_PxTransform_Pod, q));
        structGen.addField("physx_PxVec3_Pod p", "p", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTransform_Pod, p));
        structGen.endStruct(sizeof(physx::PxTransform));
    }
};
physx_PxTransform_Pod::dumpLayout(structGen);

struct physx_PxVec4_Pod: public physx::PxVec4 {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVec4_Pod", "PxVec4");
        structGen.addField("float x", "x", "f32",sizeof(float), unsafe_offsetof(physx_PxVec4_Pod, x));
        structGen.addField("float y", "y", "f32",sizeof(float), unsafe_offsetof(physx_PxVec4_Pod, y));
        structGen.addField("float z", "z", "f32",sizeof(float), unsafe_offsetof(physx_PxVec4_Pod, z));
        structGen.addField("float w", "w", "f32",sizeof(float), unsafe_offsetof(physx_PxVec4_Pod, w));
        structGen.endStruct(sizeof(physx::PxVec4));
    }
};
physx_PxVec4_Pod::dumpLayout(structGen);

struct physx_PxMat44_Pod: public physx::PxMat44 {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxMat44_Pod", "PxMat44");
        structGen.addField("physx_PxVec4_Pod column0", "column0", "PxVec4",sizeof(physx::PxVec4), unsafe_offsetof(physx_PxMat44_Pod, column0));
        structGen.addField("physx_PxVec4_Pod column1", "column1", "PxVec4",sizeof(physx::PxVec4), unsafe_offsetof(physx_PxMat44_Pod, column1));
        structGen.addField("physx_PxVec4_Pod column2", "column2", "PxVec4",sizeof(physx::PxVec4), unsafe_offsetof(physx_PxMat44_Pod, column2));
        structGen.addField("physx_PxVec4_Pod column3", "column3", "PxVec4",sizeof(physx::PxVec4), unsafe_offsetof(physx_PxMat44_Pod, column3));
        structGen.endStruct(sizeof(physx::PxMat44));
    }
};
physx_PxMat44_Pod::dumpLayout(structGen);

struct physx_PxBounds3_Pod: public physx::PxBounds3 {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBounds3_Pod", "PxBounds3");
        structGen.addField("physx_PxVec3_Pod minimum", "minimum", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxBounds3_Pod, minimum));
        structGen.addField("physx_PxVec3_Pod maximum", "maximum", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxBounds3_Pod, maximum));
        structGen.endStruct(sizeof(physx::PxBounds3));
    }
};
physx_PxBounds3_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxErrorCallback_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxInputStream_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxInputData_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxOutputStream_Pod {\n    void* vtable_;\n};\n");
struct physx_PxVec2_Pod: public physx::PxVec2 {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVec2_Pod", "PxVec2");
        structGen.addField("float x", "x", "f32",sizeof(float), unsafe_offsetof(physx_PxVec2_Pod, x));
        structGen.addField("float y", "y", "f32",sizeof(float), unsafe_offsetof(physx_PxVec2_Pod, y));
        structGen.endStruct(sizeof(physx::PxVec2));
    }
};
physx_PxVec2_Pod::dumpLayout(structGen);

struct physx_PxStridedData_Pod: public physx::PxStridedData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxStridedData_Pod", "PxStridedData");
        structGen.addField("uint32_t stride", "stride", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxStridedData_Pod, stride));
        structGen.addField("void* data", "data", "*const std::ffi::c_void",sizeof(const void *), unsafe_offsetof(physx_PxStridedData_Pod, data));
        structGen.endStruct(sizeof(physx::PxStridedData));
    }
};
physx_PxStridedData_Pod::dumpLayout(structGen);

struct physx_PxBoundedData_Pod: public physx::PxBoundedData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBoundedData_Pod", "PxBoundedData");
        structGen.addField("uint32_t stride", "stride", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBoundedData_Pod, stride));
        structGen.addField("void* data", "data", "*const std::ffi::c_void",sizeof(const void *), unsafe_offsetof(physx_PxBoundedData_Pod, data));
        structGen.addField("uint32_t count", "count", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBoundedData_Pod, count));
        structGen.endStruct(sizeof(physx::PxBoundedData));
    }
};
physx_PxBoundedData_Pod::dumpLayout(structGen);

struct physx_PxDebugPoint_Pod: public physx::PxDebugPoint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxDebugPoint_Pod", "PxDebugPoint");
        structGen.addField("physx_PxVec3_Pod pos", "pos", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugPoint_Pod, pos));
        structGen.addField("uint32_t color", "color", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxDebugPoint_Pod, color));
        structGen.endStruct(sizeof(physx::PxDebugPoint));
    }
};
physx_PxDebugPoint_Pod::dumpLayout(structGen);

struct physx_PxDebugLine_Pod: public physx::PxDebugLine {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxDebugLine_Pod", "PxDebugLine");
        structGen.addField("physx_PxVec3_Pod pos0", "pos0", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugLine_Pod, pos0));
        structGen.addField("uint32_t color0", "color0", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxDebugLine_Pod, color0));
        structGen.addField("physx_PxVec3_Pod pos1", "pos1", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugLine_Pod, pos1));
        structGen.addField("uint32_t color1", "color1", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxDebugLine_Pod, color1));
        structGen.endStruct(sizeof(physx::PxDebugLine));
    }
};
physx_PxDebugLine_Pod::dumpLayout(structGen);

struct physx_PxDebugTriangle_Pod: public physx::PxDebugTriangle {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxDebugTriangle_Pod", "PxDebugTriangle");
        structGen.addField("physx_PxVec3_Pod pos0", "pos0", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugTriangle_Pod, pos0));
        structGen.addField("uint32_t color0", "color0", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxDebugTriangle_Pod, color0));
        structGen.addField("physx_PxVec3_Pod pos1", "pos1", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugTriangle_Pod, pos1));
        structGen.addField("uint32_t color1", "color1", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxDebugTriangle_Pod, color1));
        structGen.addField("physx_PxVec3_Pod pos2", "pos2", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugTriangle_Pod, pos2));
        structGen.addField("uint32_t color2", "color2", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxDebugTriangle_Pod, color2));
        structGen.endStruct(sizeof(physx::PxDebugTriangle));
    }
};
physx_PxDebugTriangle_Pod::dumpLayout(structGen);

struct physx_PxDebugText_Pod: public physx::PxDebugText {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxDebugText_Pod", "PxDebugText");
        structGen.addField("physx_PxVec3_Pod position", "position", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugText_Pod, position));
        structGen.addField("float size", "size", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxDebugText_Pod, size));
        structGen.addField("uint32_t color", "color", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxDebugText_Pod, color));
        structGen.addField("char* string", "string", "*const i8",sizeof(const char *), unsafe_offsetof(physx_PxDebugText_Pod, string));
        structGen.endStruct(sizeof(physx::PxDebugText));
    }
};
physx_PxDebugText_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxRenderBuffer_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxProcessPxBaseCallback_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxBaseFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxBase_Pod: public physx::PxBase {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBase_Pod", "PxBase");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxBase_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxBase_Pod, mBaseFlags));
        structGen.endStruct(sizeof(physx::PxBase));
    }
};
physx_PxBase_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxSerializationContext_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxCollection_Pod {\n    void* vtable_;\n};\n");
struct physx_PxDeserializationContext_Pod: public physx::PxDeserializationContext {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxDeserializationContext_Pod", "PxDeserializationContext");
        structGen.addField("unsigned char* mExtraDataAddress", "mExtraDataAddress", "*mut u8",sizeof(physx::PxU8 *), unsafe_offsetof(physx_PxDeserializationContext_Pod, mExtraDataAddress));
        structGen.endStruct(sizeof(physx::PxDeserializationContext));
    }
};
physx_PxDeserializationContext_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxSerializationRegistry_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxSerializer_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxRepXSerializer_Pod {\n    void* vtable_;\n};\n");
struct physx_PxTolerancesScale_Pod: public physx::PxTolerancesScale {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxTolerancesScale_Pod", "PxTolerancesScale");
        structGen.addField("float length", "length", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxTolerancesScale_Pod, length));
        structGen.addField("float speed", "speed", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxTolerancesScale_Pod, speed));
        structGen.endStruct(sizeof(physx::PxTolerancesScale));
    }
};
physx_PxTolerancesScale_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxStringTable_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxFoundation_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxProfilerCallback_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxPhysicsInsertionCallback_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxTaskManager_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxCpuDispatcher_Pod {\n    void* vtable_;\n};\n");
struct physx_PxTask_Pod: public physx::PxTask {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxTask_Pod", "PxTask");
        structGen.addField("uint64_t mContextID", "mContextID", "usize",sizeof(physx::PxU64), unsafe_offsetof(physx_PxTask_Pod, mContextID));
        structGen.addField("physx_PxTaskManager_Pod* mTm", "mTm", "*mut PxTaskManager",sizeof(physx::PxTaskManager *), unsafe_offsetof(physx_PxTask_Pod, mTm));
        structGen.addField("uint32_t mTaskID", "mTaskID", "u32",sizeof(physx::PxTaskID), unsafe_offsetof(physx_PxTask_Pod, mTaskID));
        structGen.endStruct(sizeof(physx::PxTask));
    }
};
physx_PxTask_Pod::dumpLayout(structGen);

struct physx_PxBaseTask_Pod: public physx::PxBaseTask {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBaseTask_Pod", "PxBaseTask");
        structGen.addField("uint64_t mContextID", "mContextID", "usize",sizeof(physx::PxU64), unsafe_offsetof(physx_PxBaseTask_Pod, mContextID));
        structGen.addField("physx_PxTaskManager_Pod* mTm", "mTm", "*mut PxTaskManager",sizeof(physx::PxTaskManager *), unsafe_offsetof(physx_PxBaseTask_Pod, mTm));
        structGen.endStruct(sizeof(physx::PxBaseTask));
    }
};
physx_PxBaseTask_Pod::dumpLayout(structGen);

struct physx_PxLightCpuTask_Pod: public physx::PxLightCpuTask {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxLightCpuTask_Pod", "PxLightCpuTask");
        structGen.addField("uint64_t mContextID", "mContextID", "usize",sizeof(physx::PxU64), unsafe_offsetof(physx_PxLightCpuTask_Pod, mContextID));
        structGen.addField("physx_PxTaskManager_Pod* mTm", "mTm", "*mut PxTaskManager",sizeof(physx::PxTaskManager *), unsafe_offsetof(physx_PxLightCpuTask_Pod, mTm));
        structGen.addField("physx_PxBaseTask_Pod* mCont", "mCont", "*mut PxBaseTask",sizeof(physx::PxBaseTask *), unsafe_offsetof(physx_PxLightCpuTask_Pod, mCont));
        structGen.addField("int32_t mRefCount", "mRefCount", "i32",sizeof(volatile int32_t), unsafe_offsetof(physx_PxLightCpuTask_Pod, mRefCount));
        structGen.endStruct(sizeof(physx::PxLightCpuTask));
    }
};
physx_PxLightCpuTask_Pod::dumpLayout(structGen);

struct physx_PxGeometry_Pod: public physx::PxGeometry {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxGeometry_Pod", "PxGeometry");
        structGen.addField("int mType", "mType", "i32",sizeof(PxGeometryType::Enum), unsafe_offsetof(physx_PxGeometry_Pod, mType));
        structGen.endStruct(sizeof(physx::PxGeometry));
    }
};
physx_PxGeometry_Pod::dumpLayout(structGen);

struct physx_PxBoxGeometry_Pod: public physx::PxBoxGeometry {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBoxGeometry_Pod", "PxBoxGeometry");
        structGen.addField("int mType", "mType", "i32",sizeof(PxGeometryType::Enum), unsafe_offsetof(physx_PxBoxGeometry_Pod, mType));
        structGen.addField("physx_PxVec3_Pod halfExtents", "halfExtents", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxBoxGeometry_Pod, halfExtents));
        structGen.endStruct(sizeof(physx::PxBoxGeometry));
    }
};
physx_PxBoxGeometry_Pod::dumpLayout(structGen);

struct physx_PxBVHStructure_Pod: public physx::PxBVHStructure {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBVHStructure_Pod", "PxBVHStructure");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxBVHStructure_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxBVHStructure_Pod, mBaseFlags));
        structGen.endStruct(sizeof(physx::PxBVHStructure));
    }
};
physx_PxBVHStructure_Pod::dumpLayout(structGen);

struct physx_PxCapsuleGeometry_Pod: public physx::PxCapsuleGeometry {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxCapsuleGeometry_Pod", "PxCapsuleGeometry");
        structGen.addField("int mType", "mType", "i32",sizeof(PxGeometryType::Enum), unsafe_offsetof(physx_PxCapsuleGeometry_Pod, mType));
        structGen.addField("float radius", "radius", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxCapsuleGeometry_Pod, radius));
        structGen.addField("float halfHeight", "halfHeight", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxCapsuleGeometry_Pod, halfHeight));
        structGen.endStruct(sizeof(physx::PxCapsuleGeometry));
    }
};
physx_PxCapsuleGeometry_Pod::dumpLayout(structGen);

struct physx_PxConvexMesh_Pod: public physx::PxConvexMesh {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxConvexMesh_Pod", "PxConvexMesh");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxConvexMesh_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxConvexMesh_Pod, mBaseFlags));
        structGen.endStruct(sizeof(physx::PxConvexMesh));
    }
};
physx_PxConvexMesh_Pod::dumpLayout(structGen);

struct physx_PxHullPolygon_Pod: public physx::PxHullPolygon {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxHullPolygon_Pod", "PxHullPolygon");
        structGen.addField("float mPlane[4]", "mPlane", "[f32; 4]",sizeof(physx::PxReal[4]), unsafe_offsetof(physx_PxHullPolygon_Pod, mPlane));
        structGen.addField("uint16_t mNbVerts", "mNbVerts", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxHullPolygon_Pod, mNbVerts));
        structGen.addField("uint16_t mIndexBase", "mIndexBase", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxHullPolygon_Pod, mIndexBase));
        structGen.endStruct(sizeof(physx::PxHullPolygon));
    }
};
physx_PxHullPolygon_Pod::dumpLayout(structGen);

struct physx_PxMeshScale_Pod: public physx::PxMeshScale {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxMeshScale_Pod", "PxMeshScale");
        structGen.addField("physx_PxVec3_Pod scale", "scale", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxMeshScale_Pod, scale));
        structGen.addField("physx_PxQuat_Pod rotation", "rotation", "PxQuat",sizeof(physx::PxQuat), unsafe_offsetof(physx_PxMeshScale_Pod, rotation));
        structGen.endStruct(sizeof(physx::PxMeshScale));
    }
};
physx_PxMeshScale_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxConvexMeshGeometryFlags_Pod {\n    unsigned char mBits;\n};\n");
structGen.passThroughC("struct PxPadding_3__Pod {\n    unsigned char mPadding[3];\n};\n");
struct physx_PxConvexMeshGeometry_Pod: public physx::PxConvexMeshGeometry {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxConvexMeshGeometry_Pod", "PxConvexMeshGeometry");
        structGen.addField("int mType", "mType", "i32",sizeof(PxGeometryType::Enum), unsafe_offsetof(physx_PxConvexMeshGeometry_Pod, mType));
        structGen.addField("physx_PxMeshScale_Pod scale", "scale", "PxMeshScale",sizeof(physx::PxMeshScale), unsafe_offsetof(physx_PxConvexMeshGeometry_Pod, scale));
        structGen.addField("physx_PxConvexMesh_Pod* convexMesh", "convexMesh", "*mut PxConvexMesh",sizeof(physx::PxConvexMesh *), unsafe_offsetof(physx_PxConvexMeshGeometry_Pod, convexMesh));
        structGen.addField("physx_PxConvexMeshGeometryFlags_Pod meshFlags", "meshFlags", "PxConvexMeshGeometryFlags",sizeof(physx::PxConvexMeshGeometryFlags), unsafe_offsetof(physx_PxConvexMeshGeometry_Pod, meshFlags));
        structGen.addField("PxPadding_3__Pod paddingFromFlags", "paddingFromFlags", "PxPadding_3_",sizeof(PxPadding<3>), unsafe_offsetof(physx_PxConvexMeshGeometry_Pod, paddingFromFlags));
        structGen.endStruct(sizeof(physx::PxConvexMeshGeometry));
    }
};
physx_PxConvexMeshGeometry_Pod::dumpLayout(structGen);

struct physx_PxSphereGeometry_Pod: public physx::PxSphereGeometry {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSphereGeometry_Pod", "PxSphereGeometry");
        structGen.addField("int mType", "mType", "i32",sizeof(PxGeometryType::Enum), unsafe_offsetof(physx_PxSphereGeometry_Pod, mType));
        structGen.addField("float radius", "radius", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSphereGeometry_Pod, radius));
        structGen.endStruct(sizeof(physx::PxSphereGeometry));
    }
};
physx_PxSphereGeometry_Pod::dumpLayout(structGen);

struct physx_PxPlaneGeometry_Pod: public physx::PxPlaneGeometry {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxPlaneGeometry_Pod", "PxPlaneGeometry");
        structGen.addField("int mType", "mType", "i32",sizeof(PxGeometryType::Enum), unsafe_offsetof(physx_PxPlaneGeometry_Pod, mType));
        structGen.endStruct(sizeof(physx::PxPlaneGeometry));
    }
};
physx_PxPlaneGeometry_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxMeshGeometryFlags_Pod {\n    unsigned char mBits;\n};\n");
struct physx_PxTriangleMesh_Pod: public physx::PxTriangleMesh {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxTriangleMesh_Pod", "PxTriangleMesh");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxTriangleMesh_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxTriangleMesh_Pod, mBaseFlags));
        structGen.endStruct(sizeof(physx::PxTriangleMesh));
    }
};
physx_PxTriangleMesh_Pod::dumpLayout(structGen);

struct physx_PxTriangleMeshGeometry_Pod: public physx::PxTriangleMeshGeometry {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxTriangleMeshGeometry_Pod", "PxTriangleMeshGeometry");
        structGen.addField("int mType", "mType", "i32",sizeof(PxGeometryType::Enum), unsafe_offsetof(physx_PxTriangleMeshGeometry_Pod, mType));
        structGen.addField("physx_PxMeshScale_Pod scale", "scale", "PxMeshScale",sizeof(physx::PxMeshScale), unsafe_offsetof(physx_PxTriangleMeshGeometry_Pod, scale));
        structGen.addField("physx_PxMeshGeometryFlags_Pod meshFlags", "meshFlags", "PxMeshGeometryFlags",sizeof(physx::PxMeshGeometryFlags), unsafe_offsetof(physx_PxTriangleMeshGeometry_Pod, meshFlags));
        structGen.addField("PxPadding_3__Pod paddingFromFlags", "paddingFromFlags", "PxPadding_3_",sizeof(PxPadding<3>), unsafe_offsetof(physx_PxTriangleMeshGeometry_Pod, paddingFromFlags));
        structGen.addField("physx_PxTriangleMesh_Pod* triangleMesh", "triangleMesh", "*mut PxTriangleMesh",sizeof(physx::PxTriangleMesh *), unsafe_offsetof(physx_PxTriangleMeshGeometry_Pod, triangleMesh));
        structGen.endStruct(sizeof(physx::PxTriangleMeshGeometry));
    }
};
physx_PxTriangleMeshGeometry_Pod::dumpLayout(structGen);

struct physx_PxHeightField_Pod: public physx::PxHeightField {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxHeightField_Pod", "PxHeightField");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxHeightField_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxHeightField_Pod, mBaseFlags));
        structGen.endStruct(sizeof(physx::PxHeightField));
    }
};
physx_PxHeightField_Pod::dumpLayout(structGen);

struct physx_PxHeightFieldGeometry_Pod: public physx::PxHeightFieldGeometry {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxHeightFieldGeometry_Pod", "PxHeightFieldGeometry");
        structGen.addField("int mType", "mType", "i32",sizeof(PxGeometryType::Enum), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, mType));
        structGen.addField("physx_PxHeightField_Pod* heightField", "heightField", "*mut PxHeightField",sizeof(physx::PxHeightField *), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, heightField));
        structGen.addField("float heightScale", "heightScale", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, heightScale));
        structGen.addField("float rowScale", "rowScale", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, rowScale));
        structGen.addField("float columnScale", "columnScale", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, columnScale));
        structGen.addField("physx_PxMeshGeometryFlags_Pod heightFieldFlags", "heightFieldFlags", "PxMeshGeometryFlags",sizeof(physx::PxMeshGeometryFlags), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, heightFieldFlags));
        structGen.addField("PxPadding_3__Pod paddingFromFlags", "paddingFromFlags", "PxPadding_3_",sizeof(PxPadding<3>), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, paddingFromFlags));
        structGen.endStruct(sizeof(physx::PxHeightFieldGeometry));
    }
};
physx_PxHeightFieldGeometry_Pod::dumpLayout(structGen);

structGen.passThroughC("struct Anonymous59_Pod {\n    unsigned char geometry[4];\n    unsigned char box[16];\n    unsigned char sphere[8];\n    unsigned char capsule[12];\n    unsigned char plane[4];\n    unsigned char convex[48];\n    unsigned char mesh[48];\n    unsigned char heightfield[32];\n};\n");
struct physx_PxGeometryHolder_Pod: public physx::PxGeometryHolder {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxGeometryHolder_Pod", "PxGeometryHolder");
        structGen.endStruct(sizeof(physx::PxGeometryHolder));
    }
};
physx_PxGeometryHolder_Pod::dumpLayout(structGen);

struct physx_PxRigidActor_Pod: public physx::PxRigidActor {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxRigidActor_Pod", "PxRigidActor");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxRigidActor_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxRigidActor_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxRigidActor_Pod, userData));
        structGen.endStruct(sizeof(physx::PxRigidActor));
    }
};
physx_PxRigidActor_Pod::dumpLayout(structGen);

struct physx_PxShape_Pod: public physx::PxShape {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxShape_Pod", "PxShape");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxShape_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxShape_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxShape_Pod, userData));
        structGen.endStruct(sizeof(physx::PxShape));
    }
};
physx_PxShape_Pod::dumpLayout(structGen);

struct physx_PxActorShape_Pod: public physx::PxActorShape {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxActorShape_Pod", "PxActorShape");
        structGen.addField("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxActorShape_Pod, actor));
        structGen.addField("physx_PxShape_Pod* shape", "shape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxActorShape_Pod, shape));
        structGen.endStruct(sizeof(physx::PxActorShape));
    }
};
physx_PxActorShape_Pod::dumpLayout(structGen);

struct physx_PxQueryHit_Pod: public physx::PxQueryHit {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxQueryHit_Pod", "PxQueryHit");
        structGen.addField("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxQueryHit_Pod, actor));
        structGen.addField("physx_PxShape_Pod* shape", "shape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxQueryHit_Pod, shape));
        structGen.addField("uint32_t faceIndex", "faceIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxQueryHit_Pod, faceIndex));
        structGen.endStruct(sizeof(physx::PxQueryHit));
    }
};
physx_PxQueryHit_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxHitFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxLocationHit_Pod: public physx::PxLocationHit {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxLocationHit_Pod", "PxLocationHit");
        structGen.addField("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxLocationHit_Pod, actor));
        structGen.addField("physx_PxShape_Pod* shape", "shape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxLocationHit_Pod, shape));
        structGen.addField("uint32_t faceIndex", "faceIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxLocationHit_Pod, faceIndex));
        structGen.addField("physx_PxHitFlags_Pod flags", "flags", "PxHitFlags",sizeof(physx::PxHitFlags), unsafe_offsetof(physx_PxLocationHit_Pod, flags));
        structGen.addField("physx_PxVec3_Pod position", "position", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxLocationHit_Pod, position));
        structGen.addField("physx_PxVec3_Pod normal", "normal", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxLocationHit_Pod, normal));
        structGen.addField("float distance", "distance", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxLocationHit_Pod, distance));
        structGen.endStruct(sizeof(physx::PxLocationHit));
    }
};
physx_PxLocationHit_Pod::dumpLayout(structGen);

struct physx_PxRaycastHit_Pod: public physx::PxRaycastHit {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxRaycastHit_Pod", "PxRaycastHit");
        structGen.addField("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxRaycastHit_Pod, actor));
        structGen.addField("physx_PxShape_Pod* shape", "shape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxRaycastHit_Pod, shape));
        structGen.addField("uint32_t faceIndex", "faceIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxRaycastHit_Pod, faceIndex));
        structGen.addField("physx_PxHitFlags_Pod flags", "flags", "PxHitFlags",sizeof(physx::PxHitFlags), unsafe_offsetof(physx_PxRaycastHit_Pod, flags));
        structGen.addField("physx_PxVec3_Pod position", "position", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxRaycastHit_Pod, position));
        structGen.addField("physx_PxVec3_Pod normal", "normal", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxRaycastHit_Pod, normal));
        structGen.addField("float distance", "distance", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxRaycastHit_Pod, distance));
        structGen.addField("float u", "u", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxRaycastHit_Pod, u));
        structGen.addField("float v", "v", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxRaycastHit_Pod, v));
        structGen.endStruct(sizeof(physx::PxRaycastHit));
    }
};
physx_PxRaycastHit_Pod::dumpLayout(structGen);

struct physx_PxSweepHit_Pod: public physx::PxSweepHit {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSweepHit_Pod", "PxSweepHit");
        structGen.addField("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxSweepHit_Pod, actor));
        structGen.addField("physx_PxShape_Pod* shape", "shape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxSweepHit_Pod, shape));
        structGen.addField("uint32_t faceIndex", "faceIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSweepHit_Pod, faceIndex));
        structGen.addField("physx_PxHitFlags_Pod flags", "flags", "PxHitFlags",sizeof(physx::PxHitFlags), unsafe_offsetof(physx_PxSweepHit_Pod, flags));
        structGen.addField("physx_PxVec3_Pod position", "position", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSweepHit_Pod, position));
        structGen.addField("physx_PxVec3_Pod normal", "normal", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSweepHit_Pod, normal));
        structGen.addField("float distance", "distance", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxSweepHit_Pod, distance));
        structGen.addField("uint32_t padTo16Bytes", "padTo16Bytes", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSweepHit_Pod, padTo16Bytes));
        structGen.endStruct(sizeof(physx::PxSweepHit));
    }
};
physx_PxSweepHit_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxBitAndByte_Pod {\n    unsigned char mData;\n};\n");
struct physx_PxHeightFieldSample_Pod: public physx::PxHeightFieldSample {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxHeightFieldSample_Pod", "PxHeightFieldSample");
        structGen.addField("int16_t height", "height", "i16",sizeof(physx::PxI16), unsafe_offsetof(physx_PxHeightFieldSample_Pod, height));
        structGen.addField("physx_PxBitAndByte_Pod materialIndex0", "materialIndex0", "PxBitAndByte",sizeof(physx::PxBitAndByte), unsafe_offsetof(physx_PxHeightFieldSample_Pod, materialIndex0));
        structGen.addField("physx_PxBitAndByte_Pod materialIndex1", "materialIndex1", "PxBitAndByte",sizeof(physx::PxBitAndByte), unsafe_offsetof(physx_PxHeightFieldSample_Pod, materialIndex1));
        structGen.endStruct(sizeof(physx::PxHeightFieldSample));
    }
};
physx_PxHeightFieldSample_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxHeightFieldFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxHeightFieldDesc_Pod: public physx::PxHeightFieldDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxHeightFieldDesc_Pod", "PxHeightFieldDesc");
        structGen.addField("uint32_t nbRows", "nbRows", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, nbRows));
        structGen.addField("uint32_t nbColumns", "nbColumns", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, nbColumns));
        structGen.addField("unsigned int format", "format", "u32",sizeof(PxHeightFieldFormat::Enum), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, format));
        structGen.addField("physx_PxStridedData_Pod samples", "samples", "PxStridedData",sizeof(physx::PxStridedData), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, samples));
        structGen.addField("float convexEdgeThreshold", "convexEdgeThreshold", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, convexEdgeThreshold));
        structGen.addField("physx_PxHeightFieldFlags_Pod flags", "flags", "PxHeightFieldFlags",sizeof(physx::PxHeightFieldFlags), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, flags));
        structGen.endStruct(sizeof(physx::PxHeightFieldDesc));
    }
};
physx_PxHeightFieldDesc_Pod::dumpLayout(structGen);

struct physx_PxTriangle_Pod: public physx::PxTriangle {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxTriangle_Pod", "PxTriangle");
        structGen.addField("physx_PxVec3_Pod verts[3]", "verts", "[PxVec3; 3]",sizeof(physx::PxVec3[3]), unsafe_offsetof(physx_PxTriangle_Pod, verts));
        structGen.endStruct(sizeof(physx::PxTriangle));
    }
};
physx_PxTriangle_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxMeshFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxSimpleTriangleMesh_Pod: public physx::PxSimpleTriangleMesh {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSimpleTriangleMesh_Pod", "PxSimpleTriangleMesh");
        structGen.addField("physx_PxBoundedData_Pod points", "points", "PxBoundedData",sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxSimpleTriangleMesh_Pod, points));
        structGen.addField("physx_PxBoundedData_Pod triangles", "triangles", "PxBoundedData",sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxSimpleTriangleMesh_Pod, triangles));
        structGen.addField("physx_PxMeshFlags_Pod flags", "flags", "PxMeshFlags",sizeof(physx::PxMeshFlags), unsafe_offsetof(physx_PxSimpleTriangleMesh_Pod, flags));
        structGen.endStruct(sizeof(physx::PxSimpleTriangleMesh));
    }
};
physx_PxSimpleTriangleMesh_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxTriangleMeshFlags_Pod {\n    unsigned char mBits;\n};\n");
struct physx_PxActor_Pod: public physx::PxActor {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxActor_Pod", "PxActor");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxActor_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxActor_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxActor_Pod, userData));
        structGen.endStruct(sizeof(physx::PxActor));
    }
};
physx_PxActor_Pod::dumpLayout(structGen);

struct physx_PxScene_Pod: public physx::PxScene {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxScene_Pod", "PxScene");
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxScene_Pod, userData));
        structGen.endStruct(sizeof(physx::PxScene));
    }
};
physx_PxScene_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxActorFlags_Pod {\n    unsigned char mBits;\n};\n");
struct physx_PxAggregate_Pod: public physx::PxAggregate {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxAggregate_Pod", "PxAggregate");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxAggregate_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxAggregate_Pod, mBaseFlags));
        structGen.endStruct(sizeof(physx::PxAggregate));
    }
};
physx_PxAggregate_Pod::dumpLayout(structGen);

struct physx_PxArticulationBase_Pod: public physx::PxArticulationBase {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxArticulationBase_Pod", "PxArticulationBase");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxArticulationBase_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxArticulationBase_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxArticulationBase_Pod, userData));
        structGen.endStruct(sizeof(physx::PxArticulationBase));
    }
};
physx_PxArticulationBase_Pod::dumpLayout(structGen);

struct physx_PxArticulationLink_Pod: public physx::PxArticulationLink {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxArticulationLink_Pod", "PxArticulationLink");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxArticulationLink_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxArticulationLink_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxArticulationLink_Pod, userData));
        structGen.endStruct(sizeof(physx::PxArticulationLink));
    }
};
physx_PxArticulationLink_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxArticulationImpl_Pod;\n");
struct physx_PxArticulationJointBase_Pod: public physx::PxArticulationJointBase {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxArticulationJointBase_Pod", "PxArticulationJointBase");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxArticulationJointBase_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxArticulationJointBase_Pod, mBaseFlags));
        structGen.endStruct(sizeof(physx::PxArticulationJointBase));
    }
};
physx_PxArticulationJointBase_Pod::dumpLayout(structGen);

struct physx_PxArticulation_Pod: public physx::PxArticulation {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxArticulation_Pod", "PxArticulation");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxArticulation_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxArticulation_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxArticulation_Pod, userData));
        structGen.endStruct(sizeof(physx::PxArticulation));
    }
};
physx_PxArticulation_Pod::dumpLayout(structGen);

struct physx_PxArticulationDriveCache_Pod: public physx::PxArticulationDriveCache {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxArticulationDriveCache_Pod", "PxArticulationDriveCache");
        structGen.endStruct(sizeof(physx::PxArticulationDriveCache));
    }
};
physx_PxArticulationDriveCache_Pod::dumpLayout(structGen);

struct physx_PxConstraintInvMassScale_Pod: public physx::PxConstraintInvMassScale {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxConstraintInvMassScale_Pod", "PxConstraintInvMassScale");
        structGen.addField("float linear0", "linear0", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxConstraintInvMassScale_Pod, linear0));
        structGen.addField("float angular0", "angular0", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxConstraintInvMassScale_Pod, angular0));
        structGen.addField("float linear1", "linear1", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxConstraintInvMassScale_Pod, linear1));
        structGen.addField("float angular1", "angular1", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxConstraintInvMassScale_Pod, angular1));
        structGen.endStruct(sizeof(physx::PxConstraintInvMassScale));
    }
};
physx_PxConstraintInvMassScale_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxConstraintVisualizer_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxConstraintConnector_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_pvdsdk_PvdDataStream_Pod;\n");
struct physx_PxConstraint_Pod: public physx::PxConstraint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxConstraint_Pod", "PxConstraint");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxConstraint_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxConstraint_Pod, mBaseFlags));
        structGen.endStruct(sizeof(physx::PxConstraint));
    }
};
physx_PxConstraint_Pod::dumpLayout(structGen);

struct physx_PxSolverBody_Pod: public physx::PxSolverBody {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSolverBody_Pod", "PxSolverBody");
        structGen.addField("physx_PxVec3_Pod linearVelocity", "linearVelocity", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSolverBody_Pod, linearVelocity));
        structGen.addField("uint16_t maxSolverNormalProgress", "maxSolverNormalProgress", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxSolverBody_Pod, maxSolverNormalProgress));
        structGen.addField("uint16_t maxSolverFrictionProgress", "maxSolverFrictionProgress", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxSolverBody_Pod, maxSolverFrictionProgress));
        structGen.addField("physx_PxVec3_Pod angularState", "angularState", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSolverBody_Pod, angularState));
        structGen.addField("uint32_t solverProgress", "solverProgress", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSolverBody_Pod, solverProgress));
        structGen.endStruct(sizeof(physx::PxSolverBody));
    }
};
physx_PxSolverBody_Pod::dumpLayout(structGen);

struct physx_PxSolverBodyData_Pod: public physx::PxSolverBodyData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSolverBodyData_Pod", "PxSolverBodyData");
        structGen.addField("physx_PxVec3_Pod linearVelocity", "linearVelocity", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSolverBodyData_Pod, linearVelocity));
        structGen.addField("float invMass", "invMass", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSolverBodyData_Pod, invMass));
        structGen.addField("physx_PxVec3_Pod angularVelocity", "angularVelocity", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSolverBodyData_Pod, angularVelocity));
        structGen.addField("float reportThreshold", "reportThreshold", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSolverBodyData_Pod, reportThreshold));
        structGen.addField("physx_PxMat33_Pod sqrtInvInertia", "sqrtInvInertia", "PxMat33",sizeof(physx::PxMat33), unsafe_offsetof(physx_PxSolverBodyData_Pod, sqrtInvInertia));
        structGen.addField("float penBiasClamp", "penBiasClamp", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSolverBodyData_Pod, penBiasClamp));
        structGen.addField("uint32_t nodeIndex", "nodeIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSolverBodyData_Pod, nodeIndex));
        structGen.addField("float maxContactImpulse", "maxContactImpulse", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSolverBodyData_Pod, maxContactImpulse));
        structGen.addField("physx_PxTransform_Pod body2World", "body2World", "PxTransform",sizeof(physx::PxTransform), unsafe_offsetof(physx_PxSolverBodyData_Pod, body2World));
        structGen.addField("uint16_t lockFlags", "lockFlags", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxSolverBodyData_Pod, lockFlags));
        structGen.addField("uint16_t pad", "pad", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxSolverBodyData_Pod, pad));
        structGen.endStruct(sizeof(physx::PxSolverBodyData));
    }
};
physx_PxSolverBodyData_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxConstraintAllocator_Pod {\n    void* vtable_;\n};\n");
struct physx_PxTGSSolverBodyVel_Pod: public physx::PxTGSSolverBodyVel {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxTGSSolverBodyVel_Pod", "PxTGSSolverBodyVel");
        structGen.addField("physx_PxVec3_Pod linearVelocity", "linearVelocity", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, linearVelocity));
        structGen.addField("uint16_t nbStaticInteractions", "nbStaticInteractions", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, nbStaticInteractions));
        structGen.addField("uint16_t maxDynamicPartition", "maxDynamicPartition", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, maxDynamicPartition));
        structGen.addField("physx_PxVec3_Pod angularVelocity", "angularVelocity", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, angularVelocity));
        structGen.addField("uint32_t partitionMask", "partitionMask", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, partitionMask));
        structGen.addField("physx_PxVec3_Pod deltaAngDt", "deltaAngDt", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, deltaAngDt));
        structGen.addField("float maxAngVel", "maxAngVel", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, maxAngVel));
        structGen.addField("physx_PxVec3_Pod deltaLinDt", "deltaLinDt", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, deltaLinDt));
        structGen.addField("uint16_t lockFlags", "lockFlags", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, lockFlags));
        structGen.addField("bool isKinematic", "isKinematic", "bool",sizeof(bool), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, isKinematic));
        structGen.addField("unsigned char pad", "pad", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, pad));
        structGen.endStruct(sizeof(physx::PxTGSSolverBodyVel));
    }
};
physx_PxTGSSolverBodyVel_Pod::dumpLayout(structGen);

struct physx_PxTGSSolverBodyData_Pod: public physx::PxTGSSolverBodyData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxTGSSolverBodyData_Pod", "PxTGSSolverBodyData");
        structGen.addField("physx_PxVec3_Pod originalLinearVelocity", "originalLinearVelocity", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, originalLinearVelocity));
        structGen.addField("float maxContactImpulse", "maxContactImpulse", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, maxContactImpulse));
        structGen.addField("physx_PxVec3_Pod originalAngularVelocity", "originalAngularVelocity", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, originalAngularVelocity));
        structGen.addField("float penBiasClamp", "penBiasClamp", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, penBiasClamp));
        structGen.addField("float invMass", "invMass", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, invMass));
        structGen.addField("uint32_t nodeIndex", "nodeIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, nodeIndex));
        structGen.addField("float reportThreshold", "reportThreshold", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, reportThreshold));
        structGen.addField("uint32_t pad", "pad", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, pad));
        structGen.endStruct(sizeof(physx::PxTGSSolverBodyData));
    }
};
physx_PxTGSSolverBodyData_Pod::dumpLayout(structGen);

struct physx_PxSpatialForce_Pod: public physx::PxSpatialForce {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSpatialForce_Pod", "PxSpatialForce");
        structGen.addField("physx_PxVec3_Pod force", "force", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSpatialForce_Pod, force));
        structGen.addField("float pad0", "pad0", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSpatialForce_Pod, pad0));
        structGen.addField("physx_PxVec3_Pod torque", "torque", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSpatialForce_Pod, torque));
        structGen.addField("float pad1", "pad1", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSpatialForce_Pod, pad1));
        structGen.endStruct(sizeof(physx::PxSpatialForce));
    }
};
physx_PxSpatialForce_Pod::dumpLayout(structGen);

struct physx_PxSpatialVelocity_Pod: public physx::PxSpatialVelocity {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSpatialVelocity_Pod", "PxSpatialVelocity");
        structGen.addField("physx_PxVec3_Pod linear", "linear", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSpatialVelocity_Pod, linear));
        structGen.addField("float pad0", "pad0", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSpatialVelocity_Pod, pad0));
        structGen.addField("physx_PxVec3_Pod angular", "angular", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSpatialVelocity_Pod, angular));
        structGen.addField("float pad1", "pad1", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSpatialVelocity_Pod, pad1));
        structGen.endStruct(sizeof(physx::PxSpatialVelocity));
    }
};
physx_PxSpatialVelocity_Pod::dumpLayout(structGen);

struct physx_PxArticulationRootLinkData_Pod: public physx::PxArticulationRootLinkData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxArticulationRootLinkData_Pod", "PxArticulationRootLinkData");
        structGen.addField("physx_PxTransform_Pod transform", "transform", "PxTransform",sizeof(physx::PxTransform), unsafe_offsetof(physx_PxArticulationRootLinkData_Pod, transform));
        structGen.addField("physx_PxVec3_Pod worldLinVel", "worldLinVel", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxArticulationRootLinkData_Pod, worldLinVel));
        structGen.addField("physx_PxVec3_Pod worldAngVel", "worldAngVel", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxArticulationRootLinkData_Pod, worldAngVel));
        structGen.addField("physx_PxVec3_Pod worldLinAccel", "worldLinAccel", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxArticulationRootLinkData_Pod, worldLinAccel));
        structGen.addField("physx_PxVec3_Pod worldAngAccel", "worldAngAccel", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxArticulationRootLinkData_Pod, worldAngAccel));
        structGen.endStruct(sizeof(physx::PxArticulationRootLinkData));
    }
};
physx_PxArticulationRootLinkData_Pod::dumpLayout(structGen);

struct physx_PxArticulationCache_Pod: public physx::PxArticulationCache {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxArticulationCache_Pod", "PxArticulationCache");
        structGen.addField("physx_PxSpatialForce_Pod* externalForces", "externalForces", "*mut PxSpatialForce",sizeof(physx::PxSpatialForce *), unsafe_offsetof(physx_PxArticulationCache_Pod, externalForces));
        structGen.addField("float* denseJacobian", "denseJacobian", "*mut f32",sizeof(physx::PxReal *), unsafe_offsetof(physx_PxArticulationCache_Pod, denseJacobian));
        structGen.addField("float* massMatrix", "massMatrix", "*mut f32",sizeof(physx::PxReal *), unsafe_offsetof(physx_PxArticulationCache_Pod, massMatrix));
        structGen.addField("float* jointVelocity", "jointVelocity", "*mut f32",sizeof(physx::PxReal *), unsafe_offsetof(physx_PxArticulationCache_Pod, jointVelocity));
        structGen.addField("float* jointAcceleration", "jointAcceleration", "*mut f32",sizeof(physx::PxReal *), unsafe_offsetof(physx_PxArticulationCache_Pod, jointAcceleration));
        structGen.addField("float* jointPosition", "jointPosition", "*mut f32",sizeof(physx::PxReal *), unsafe_offsetof(physx_PxArticulationCache_Pod, jointPosition));
        structGen.addField("float* jointForce", "jointForce", "*mut f32",sizeof(physx::PxReal *), unsafe_offsetof(physx_PxArticulationCache_Pod, jointForce));
        structGen.addField("physx_PxSpatialVelocity_Pod* linkVelocity", "linkVelocity", "*mut PxSpatialVelocity",sizeof(physx::PxSpatialVelocity *), unsafe_offsetof(physx_PxArticulationCache_Pod, linkVelocity));
        structGen.addField("physx_PxSpatialVelocity_Pod* linkAcceleration", "linkAcceleration", "*mut PxSpatialVelocity",sizeof(physx::PxSpatialVelocity *), unsafe_offsetof(physx_PxArticulationCache_Pod, linkAcceleration));
        structGen.addField("physx_PxArticulationRootLinkData_Pod* rootLinkData", "rootLinkData", "*mut PxArticulationRootLinkData",sizeof(physx::PxArticulationRootLinkData *), unsafe_offsetof(physx_PxArticulationCache_Pod, rootLinkData));
        structGen.addField("float* coefficientMatrix", "coefficientMatrix", "*mut f32",sizeof(physx::PxReal *), unsafe_offsetof(physx_PxArticulationCache_Pod, coefficientMatrix));
        structGen.addField("float* lambda", "lambda", "*mut f32",sizeof(physx::PxReal *), unsafe_offsetof(physx_PxArticulationCache_Pod, lambda));
        structGen.addField("void* scratchMemory", "scratchMemory", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxArticulationCache_Pod, scratchMemory));
        structGen.addField("void* scratchAllocator", "scratchAllocator", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxArticulationCache_Pod, scratchAllocator));
        structGen.addField("uint32_t version", "version", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxArticulationCache_Pod, version));
        structGen.endStruct(sizeof(physx::PxArticulationCache));
    }
};
physx_PxArticulationCache_Pod::dumpLayout(structGen);

struct physx_PxArticulationReducedCoordinate_Pod: public physx::PxArticulationReducedCoordinate {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxArticulationReducedCoordinate_Pod", "PxArticulationReducedCoordinate");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxArticulationReducedCoordinate_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxArticulationReducedCoordinate_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxArticulationReducedCoordinate_Pod, userData));
        structGen.endStruct(sizeof(physx::PxArticulationReducedCoordinate));
    }
};
physx_PxArticulationReducedCoordinate_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxArticulationFlags_Pod {\n    unsigned char mBits;\n};\n");
structGen.passThroughC("struct physx_PxArticulationCacheFlags_Pod {\n    unsigned char mBits;\n};\n");
struct physx_PxJoint_Pod: public physx::PxJoint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxJoint_Pod", "PxJoint");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxJoint_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxJoint_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxJoint_Pod, userData));
        structGen.endStruct(sizeof(physx::PxJoint));
    }
};
physx_PxJoint_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxArticulationJointImpl_Pod;\n");
struct physx_PxArticulationJoint_Pod: public physx::PxArticulationJoint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxArticulationJoint_Pod", "PxArticulationJoint");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxArticulationJoint_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxArticulationJoint_Pod, mBaseFlags));
        structGen.endStruct(sizeof(physx::PxArticulationJoint));
    }
};
physx_PxArticulationJoint_Pod::dumpLayout(structGen);

struct physx_PxArticulationJointReducedCoordinate_Pod: public physx::PxArticulationJointReducedCoordinate {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxArticulationJointReducedCoordinate_Pod", "PxArticulationJointReducedCoordinate");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxArticulationJointReducedCoordinate_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxArticulationJointReducedCoordinate_Pod, mBaseFlags));
        structGen.endStruct(sizeof(physx::PxArticulationJointReducedCoordinate));
    }
};
physx_PxArticulationJointReducedCoordinate_Pod::dumpLayout(structGen);

struct physx_PxFilterData_Pod: public physx::PxFilterData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxFilterData_Pod", "PxFilterData");
        structGen.addField("uint32_t word0", "word0", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxFilterData_Pod, word0));
        structGen.addField("uint32_t word1", "word1", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxFilterData_Pod, word1));
        structGen.addField("uint32_t word2", "word2", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxFilterData_Pod, word2));
        structGen.addField("uint32_t word3", "word3", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxFilterData_Pod, word3));
        structGen.endStruct(sizeof(physx::PxFilterData));
    }
};
physx_PxFilterData_Pod::dumpLayout(structGen);

struct physx_PxMaterial_Pod: public physx::PxMaterial {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxMaterial_Pod", "PxMaterial");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxMaterial_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxMaterial_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxMaterial_Pod, userData));
        structGen.endStruct(sizeof(physx::PxMaterial));
    }
};
physx_PxMaterial_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxShapeFlags_Pod {\n    unsigned char mBits;\n};\n");
struct physx_PxRigidBody_Pod: public physx::PxRigidBody {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxRigidBody_Pod", "PxRigidBody");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxRigidBody_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxRigidBody_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxRigidBody_Pod, userData));
        structGen.endStruct(sizeof(physx::PxRigidBody));
    }
};
physx_PxRigidBody_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxRigidBodyFlags_Pod {\n    unsigned char mBits;\n};\n");
structGen.passThroughC("struct physx_PxFilterFlags_Pod {\n    uint16_t mBits;\n};\n");
structGen.passThroughC("struct physx_PxSimulationFilterCallback_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxPairFlags_Pod {\n    uint16_t mBits;\n};\n");
structGen.passThroughC("struct physx_PxQueryFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxQueryFilterData_Pod: public physx::PxQueryFilterData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxQueryFilterData_Pod", "PxQueryFilterData");
        structGen.addField("physx_PxFilterData_Pod data", "data", "PxFilterData",sizeof(physx::PxFilterData), unsafe_offsetof(physx_PxQueryFilterData_Pod, data));
        structGen.addField("physx_PxQueryFlags_Pod flags", "flags", "PxQueryFlags",sizeof(physx::PxQueryFlags), unsafe_offsetof(physx_PxQueryFilterData_Pod, flags));
        structGen.endStruct(sizeof(physx::PxQueryFilterData));
    }
};
physx_PxQueryFilterData_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxQueryFilterCallback_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxRaycastQueryResult_Pod;\n");
structGen.passThroughC("struct physx_PxSweepQueryResult_Pod;\n");
structGen.passThroughC("struct physx_PxOverlapQueryResult_Pod;\n");
struct physx_PxOverlapHit_Pod: public physx::PxOverlapHit {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxOverlapHit_Pod", "PxOverlapHit");
        structGen.addField("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxOverlapHit_Pod, actor));
        structGen.addField("physx_PxShape_Pod* shape", "shape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxOverlapHit_Pod, shape));
        structGen.addField("uint32_t faceIndex", "faceIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxOverlapHit_Pod, faceIndex));
        structGen.addField("uint32_t padTo16Bytes", "padTo16Bytes", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxOverlapHit_Pod, padTo16Bytes));
        structGen.endStruct(sizeof(physx::PxOverlapHit));
    }
};
physx_PxOverlapHit_Pod::dumpLayout(structGen);

struct physx_PxBatchQueryMemory_Pod: public physx::PxBatchQueryMemory {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBatchQueryMemory_Pod", "PxBatchQueryMemory");
        structGen.addField("physx_PxRaycastQueryResult_Pod* userRaycastResultBuffer", "userRaycastResultBuffer", "*mut PxRaycastQueryResult",sizeof(physx::PxRaycastQueryResult *), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, userRaycastResultBuffer));
        structGen.addField("physx_PxRaycastHit_Pod* userRaycastTouchBuffer", "userRaycastTouchBuffer", "*mut PxRaycastHit",sizeof(physx::PxRaycastHit *), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, userRaycastTouchBuffer));
        structGen.addField("physx_PxSweepQueryResult_Pod* userSweepResultBuffer", "userSweepResultBuffer", "*mut PxSweepQueryResult",sizeof(physx::PxSweepQueryResult *), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, userSweepResultBuffer));
        structGen.addField("physx_PxSweepHit_Pod* userSweepTouchBuffer", "userSweepTouchBuffer", "*mut PxSweepHit",sizeof(physx::PxSweepHit *), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, userSweepTouchBuffer));
        structGen.addField("physx_PxOverlapQueryResult_Pod* userOverlapResultBuffer", "userOverlapResultBuffer", "*mut PxOverlapQueryResult",sizeof(physx::PxOverlapQueryResult *), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, userOverlapResultBuffer));
        structGen.addField("physx_PxOverlapHit_Pod* userOverlapTouchBuffer", "userOverlapTouchBuffer", "*mut PxOverlapHit",sizeof(physx::PxOverlapHit *), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, userOverlapTouchBuffer));
        structGen.addField("uint32_t raycastTouchBufferSize", "raycastTouchBufferSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, raycastTouchBufferSize));
        structGen.addField("uint32_t sweepTouchBufferSize", "sweepTouchBufferSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, sweepTouchBufferSize));
        structGen.addField("uint32_t overlapTouchBufferSize", "overlapTouchBufferSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, overlapTouchBufferSize));
        structGen.addField("uint32_t raycastResultBufferSize", "raycastResultBufferSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, raycastResultBufferSize));
        structGen.addField("uint32_t sweepResultBufferSize", "sweepResultBufferSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, sweepResultBufferSize));
        structGen.addField("uint32_t overlapResultBufferSize", "overlapResultBufferSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBatchQueryMemory_Pod, overlapResultBufferSize));
        structGen.endStruct(sizeof(physx::PxBatchQueryMemory));
    }
};
physx_PxBatchQueryMemory_Pod::dumpLayout(structGen);

struct physx_PxBatchQueryDesc_Pod: public physx::PxBatchQueryDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBatchQueryDesc_Pod", "PxBatchQueryDesc");
        structGen.addField("void* filterShaderData", "filterShaderData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxBatchQueryDesc_Pod, filterShaderData));
        structGen.addField("uint32_t filterShaderDataSize", "filterShaderDataSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBatchQueryDesc_Pod, filterShaderDataSize));
        structGen.addField("void* preFilterShader", "preFilterShader", "*mut std::ffi::c_void",sizeof(physx::PxBatchQueryPreFilterShader), unsafe_offsetof(physx_PxBatchQueryDesc_Pod, preFilterShader));
        structGen.addField("void* postFilterShader", "postFilterShader", "*mut std::ffi::c_void",sizeof(physx::PxBatchQueryPostFilterShader), unsafe_offsetof(physx_PxBatchQueryDesc_Pod, postFilterShader));
        structGen.addField("physx_PxBatchQueryMemory_Pod queryMemory", "queryMemory", "PxBatchQueryMemory",sizeof(physx::PxBatchQueryMemory), unsafe_offsetof(physx_PxBatchQueryDesc_Pod, queryMemory));
        structGen.endStruct(sizeof(physx::PxBatchQueryDesc));
    }
};
physx_PxBatchQueryDesc_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxBatchQuery_Pod {\n    void* vtable_;\n};\n");
struct physx_PxQueryCache_Pod: public physx::PxQueryCache {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxQueryCache_Pod", "PxQueryCache");
        structGen.addField("physx_PxShape_Pod* shape", "shape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxQueryCache_Pod, shape));
        structGen.addField("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxQueryCache_Pod, actor));
        structGen.addField("uint32_t faceIndex", "faceIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxQueryCache_Pod, faceIndex));
        structGen.endStruct(sizeof(physx::PxQueryCache));
    }
};
physx_PxQueryCache_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxConstraintFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxConstraintShaderTable_Pod: public physx::PxConstraintShaderTable {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxConstraintShaderTable_Pod", "PxConstraintShaderTable");
        structGen.addField("void* solverPrep", "solverPrep", "*mut std::ffi::c_void",sizeof(physx::PxConstraintSolverPrep), unsafe_offsetof(physx_PxConstraintShaderTable_Pod, solverPrep));
        structGen.addField("void* project", "project", "*mut std::ffi::c_void",sizeof(physx::PxConstraintProject), unsafe_offsetof(physx_PxConstraintShaderTable_Pod, project));
        structGen.addField("void* visualize", "visualize", "*mut std::ffi::c_void",sizeof(physx::PxConstraintVisualize), unsafe_offsetof(physx_PxConstraintShaderTable_Pod, visualize));
        structGen.addField("unsigned int flag", "flag", "u32",sizeof(PxConstraintFlag::Enum), unsafe_offsetof(physx_PxConstraintShaderTable_Pod, flag));
        structGen.endStruct(sizeof(physx::PxConstraintShaderTable));
    }
};
physx_PxConstraintShaderTable_Pod::dumpLayout(structGen);

struct physx_PxMassModificationProps_Pod: public physx::PxMassModificationProps {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxMassModificationProps_Pod", "PxMassModificationProps");
        structGen.addField("float mInvMassScale0", "mInvMassScale0", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxMassModificationProps_Pod, mInvMassScale0));
        structGen.addField("float mInvInertiaScale0", "mInvInertiaScale0", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxMassModificationProps_Pod, mInvInertiaScale0));
        structGen.addField("float mInvMassScale1", "mInvMassScale1", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxMassModificationProps_Pod, mInvMassScale1));
        structGen.addField("float mInvInertiaScale1", "mInvInertiaScale1", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxMassModificationProps_Pod, mInvInertiaScale1));
        structGen.endStruct(sizeof(physx::PxMassModificationProps));
    }
};
physx_PxMassModificationProps_Pod::dumpLayout(structGen);

struct physx_PxContactPatch_Pod: public physx::PxContactPatch {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactPatch_Pod", "PxContactPatch");
        structGen.addField("physx_PxMassModificationProps_Pod mMassModification", "mMassModification", "PxMassModificationProps",sizeof(physx::PxMassModificationProps), unsafe_offsetof(physx_PxContactPatch_Pod, mMassModification));
        structGen.addField("physx_PxVec3_Pod normal", "normal", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactPatch_Pod, normal));
        structGen.addField("float restitution", "restitution", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxContactPatch_Pod, restitution));
        structGen.addField("float dynamicFriction", "dynamicFriction", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxContactPatch_Pod, dynamicFriction));
        structGen.addField("float staticFriction", "staticFriction", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxContactPatch_Pod, staticFriction));
        structGen.addField("unsigned char startContactIndex", "startContactIndex", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxContactPatch_Pod, startContactIndex));
        structGen.addField("unsigned char nbContacts", "nbContacts", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxContactPatch_Pod, nbContacts));
        structGen.addField("unsigned char materialFlags", "materialFlags", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxContactPatch_Pod, materialFlags));
        structGen.addField("unsigned char internalFlags", "internalFlags", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxContactPatch_Pod, internalFlags));
        structGen.addField("uint16_t materialIndex0", "materialIndex0", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxContactPatch_Pod, materialIndex0));
        structGen.addField("uint16_t materialIndex1", "materialIndex1", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxContactPatch_Pod, materialIndex1));
        structGen.endStruct(sizeof(physx::PxContactPatch));
    }
};
physx_PxContactPatch_Pod::dumpLayout(structGen);

struct physx_PxContact_Pod: public physx::PxContact {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContact_Pod", "PxContact");
        structGen.addField("physx_PxVec3_Pod contact", "contact", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContact_Pod, contact));
        structGen.addField("float separation", "separation", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxContact_Pod, separation));
        structGen.endStruct(sizeof(physx::PxContact));
    }
};
physx_PxContact_Pod::dumpLayout(structGen);

struct physx_PxContactStreamIterator_Pod: public physx::PxContactStreamIterator {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactStreamIterator_Pod", "PxContactStreamIterator");
        structGen.addField("physx_PxVec3_Pod zero", "zero", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactStreamIterator_Pod, zero));
        structGen.addField("physx_PxContactPatch_Pod* patch", "patch", "*const PxContactPatch",sizeof(const physx::PxContactPatch *), unsafe_offsetof(physx_PxContactStreamIterator_Pod, patch));
        structGen.addField("physx_PxContact_Pod* contact", "contact", "*const PxContact",sizeof(const physx::PxContact *), unsafe_offsetof(physx_PxContactStreamIterator_Pod, contact));
        structGen.addField("uint32_t* faceIndice", "faceIndice", "*const u32",sizeof(const physx::PxU32 *), unsafe_offsetof(physx_PxContactStreamIterator_Pod, faceIndice));
        structGen.addField("uint32_t totalPatches", "totalPatches", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactStreamIterator_Pod, totalPatches));
        structGen.addField("uint32_t totalContacts", "totalContacts", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactStreamIterator_Pod, totalContacts));
        structGen.addField("uint32_t nextContactIndex", "nextContactIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactStreamIterator_Pod, nextContactIndex));
        structGen.addField("uint32_t nextPatchIndex", "nextPatchIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactStreamIterator_Pod, nextPatchIndex));
        structGen.addField("uint32_t contactPatchHeaderSize", "contactPatchHeaderSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactStreamIterator_Pod, contactPatchHeaderSize));
        structGen.addField("uint32_t contactPointSize", "contactPointSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactStreamIterator_Pod, contactPointSize));
        structGen.addField("unsigned int mStreamFormat", "mStreamFormat", "u32",sizeof(physx::PxContactStreamIterator::StreamFormat), unsafe_offsetof(physx_PxContactStreamIterator_Pod, mStreamFormat));
        structGen.addField("uint32_t forceNoResponse", "forceNoResponse", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactStreamIterator_Pod, forceNoResponse));
        structGen.addField("bool pointStepped", "pointStepped", "bool",sizeof(bool), unsafe_offsetof(physx_PxContactStreamIterator_Pod, pointStepped));
        structGen.addField("uint32_t hasFaceIndices", "hasFaceIndices", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactStreamIterator_Pod, hasFaceIndices));
        structGen.endStruct(sizeof(physx::PxContactStreamIterator));
    }
};
physx_PxContactStreamIterator_Pod::dumpLayout(structGen);

struct physx_PxModifiableContact_Pod: public physx::PxModifiableContact {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxModifiableContact_Pod", "PxModifiableContact");
        structGen.addField("physx_PxVec3_Pod contact", "contact", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxModifiableContact_Pod, contact));
        structGen.addField("float separation", "separation", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxModifiableContact_Pod, separation));
        structGen.addField("physx_PxVec3_Pod targetVelocity", "targetVelocity", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxModifiableContact_Pod, targetVelocity));
        structGen.addField("float maxImpulse", "maxImpulse", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxModifiableContact_Pod, maxImpulse));
        structGen.addField("physx_PxVec3_Pod normal", "normal", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxModifiableContact_Pod, normal));
        structGen.addField("float restitution", "restitution", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxModifiableContact_Pod, restitution));
        structGen.addField("uint32_t materialFlags", "materialFlags", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxModifiableContact_Pod, materialFlags));
        structGen.addField("uint16_t materialIndex0", "materialIndex0", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxModifiableContact_Pod, materialIndex0));
        structGen.addField("uint16_t materialIndex1", "materialIndex1", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxModifiableContact_Pod, materialIndex1));
        structGen.addField("float staticFriction", "staticFriction", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxModifiableContact_Pod, staticFriction));
        structGen.addField("float dynamicFriction", "dynamicFriction", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxModifiableContact_Pod, dynamicFriction));
        structGen.endStruct(sizeof(physx::PxModifiableContact));
    }
};
physx_PxModifiableContact_Pod::dumpLayout(structGen);

struct physx_PxContactSet_Pod: public physx::PxContactSet {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactSet_Pod", "PxContactSet");
        structGen.addField("uint32_t mCount", "mCount", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactSet_Pod, mCount));
        structGen.addField("physx_PxModifiableContact_Pod* mContacts", "mContacts", "*mut PxModifiableContact",sizeof(physx::PxModifiableContact *), unsafe_offsetof(physx_PxContactSet_Pod, mContacts));
        structGen.endStruct(sizeof(physx::PxContactSet));
    }
};
physx_PxContactSet_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxContactModifyCallback_Pod {\n    void* vtable_;\n};\n");
struct physx_PxContactModifyPair_Pod: public physx::PxContactModifyPair {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactModifyPair_Pod", "PxContactModifyPair");
        structGen.addField("physx_PxRigidActor_Pod* actor[2]", "actor", "[*const PxRigidActor; 2]",sizeof(const physx::PxRigidActor *[2]), unsafe_offsetof(physx_PxContactModifyPair_Pod, actor));
        structGen.addField("physx_PxShape_Pod* shape[2]", "shape", "[*const PxShape; 2]",sizeof(const physx::PxShape *[2]), unsafe_offsetof(physx_PxContactModifyPair_Pod, shape));
        structGen.addField("physx_PxTransform_Pod transform[2]", "transform", "[PxTransform; 2]",sizeof(physx::PxTransform[2]), unsafe_offsetof(physx_PxContactModifyPair_Pod, transform));
        structGen.addField("physx_PxContactSet_Pod contacts", "contacts", "PxContactSet",sizeof(physx::PxContactSet), unsafe_offsetof(physx_PxContactModifyPair_Pod, contacts));
        structGen.endStruct(sizeof(physx::PxContactModifyPair));
    }
};
physx_PxContactModifyPair_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxCCDContactModifyCallback_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxDeletionListener_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxDataAccessFlags_Pod {\n    unsigned char mBits;\n};\n");
structGen.passThroughC("struct physx_PxLockedData_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxMaterialFlags_Pod {\n    uint16_t mBits;\n};\n");
structGen.passThroughC("struct physx_PxPhysics_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxSimulationEventCallback_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxBroadPhaseCallback_Pod {\n    void* vtable_;\n};\n");
struct physx_PxSceneLimits_Pod: public physx::PxSceneLimits {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSceneLimits_Pod", "PxSceneLimits");
        structGen.addField("uint32_t maxNbActors", "maxNbActors", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbActors));
        structGen.addField("uint32_t maxNbBodies", "maxNbBodies", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbBodies));
        structGen.addField("uint32_t maxNbStaticShapes", "maxNbStaticShapes", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbStaticShapes));
        structGen.addField("uint32_t maxNbDynamicShapes", "maxNbDynamicShapes", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbDynamicShapes));
        structGen.addField("uint32_t maxNbAggregates", "maxNbAggregates", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbAggregates));
        structGen.addField("uint32_t maxNbConstraints", "maxNbConstraints", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbConstraints));
        structGen.addField("uint32_t maxNbRegions", "maxNbRegions", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbRegions));
        structGen.addField("uint32_t maxNbBroadPhaseOverlaps", "maxNbBroadPhaseOverlaps", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbBroadPhaseOverlaps));
        structGen.endStruct(sizeof(physx::PxSceneLimits));
    }
};
physx_PxSceneLimits_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxSceneFlags_Pod {\n    uint32_t mBits;\n};\n");
structGen.passThroughC("struct physx_PxCudaContextManager_Pod;\n");
struct physx_PxgDynamicsMemoryConfig_Pod: public physx::PxgDynamicsMemoryConfig {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxgDynamicsMemoryConfig_Pod", "PxgDynamicsMemoryConfig");
        structGen.addField("uint32_t constraintBufferCapacity", "constraintBufferCapacity", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, constraintBufferCapacity));
        structGen.addField("uint32_t contactBufferCapacity", "contactBufferCapacity", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, contactBufferCapacity));
        structGen.addField("uint32_t tempBufferCapacity", "tempBufferCapacity", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, tempBufferCapacity));
        structGen.addField("uint32_t contactStreamSize", "contactStreamSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, contactStreamSize));
        structGen.addField("uint32_t patchStreamSize", "patchStreamSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, patchStreamSize));
        structGen.addField("uint32_t forceStreamCapacity", "forceStreamCapacity", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, forceStreamCapacity));
        structGen.addField("uint32_t heapCapacity", "heapCapacity", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, heapCapacity));
        structGen.addField("uint32_t foundLostPairsCapacity", "foundLostPairsCapacity", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, foundLostPairsCapacity));
        structGen.endStruct(sizeof(physx::PxgDynamicsMemoryConfig));
    }
};
physx_PxgDynamicsMemoryConfig_Pod::dumpLayout(structGen);

struct physx_PxSceneDesc_Pod: public physx::PxSceneDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSceneDesc_Pod", "PxSceneDesc");
        structGen.addField("physx_PxVec3_Pod gravity", "gravity", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSceneDesc_Pod, gravity));
        structGen.addField("physx_PxSimulationEventCallback_Pod* simulationEventCallback", "simulationEventCallback", "*mut PxSimulationEventCallback",sizeof(physx::PxSimulationEventCallback *), unsafe_offsetof(physx_PxSceneDesc_Pod, simulationEventCallback));
        structGen.addField("physx_PxContactModifyCallback_Pod* contactModifyCallback", "contactModifyCallback", "*mut PxContactModifyCallback",sizeof(physx::PxContactModifyCallback *), unsafe_offsetof(physx_PxSceneDesc_Pod, contactModifyCallback));
        structGen.addField("physx_PxCCDContactModifyCallback_Pod* ccdContactModifyCallback", "ccdContactModifyCallback", "*mut PxCCDContactModifyCallback",sizeof(physx::PxCCDContactModifyCallback *), unsafe_offsetof(physx_PxSceneDesc_Pod, ccdContactModifyCallback));
        structGen.addField("void* filterShaderData", "filterShaderData", "*const std::ffi::c_void",sizeof(const void *), unsafe_offsetof(physx_PxSceneDesc_Pod, filterShaderData));
        structGen.addField("uint32_t filterShaderDataSize", "filterShaderDataSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneDesc_Pod, filterShaderDataSize));
        structGen.addField("void* filterShader", "filterShader", "*mut std::ffi::c_void",sizeof(physx::PxSimulationFilterShader), unsafe_offsetof(physx_PxSceneDesc_Pod, filterShader));
        structGen.addField("physx_PxSimulationFilterCallback_Pod* filterCallback", "filterCallback", "*mut PxSimulationFilterCallback",sizeof(physx::PxSimulationFilterCallback *), unsafe_offsetof(physx_PxSceneDesc_Pod, filterCallback));
        structGen.addField("unsigned int kineKineFilteringMode", "kineKineFilteringMode", "u32",sizeof(PxPairFilteringMode::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, kineKineFilteringMode));
        structGen.addField("unsigned int staticKineFilteringMode", "staticKineFilteringMode", "u32",sizeof(PxPairFilteringMode::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, staticKineFilteringMode));
        structGen.addField("unsigned int broadPhaseType", "broadPhaseType", "u32",sizeof(PxBroadPhaseType::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, broadPhaseType));
        structGen.addField("physx_PxBroadPhaseCallback_Pod* broadPhaseCallback", "broadPhaseCallback", "*mut PxBroadPhaseCallback",sizeof(physx::PxBroadPhaseCallback *), unsafe_offsetof(physx_PxSceneDesc_Pod, broadPhaseCallback));
        structGen.addField("physx_PxSceneLimits_Pod limits", "limits", "PxSceneLimits",sizeof(physx::PxSceneLimits), unsafe_offsetof(physx_PxSceneDesc_Pod, limits));
        structGen.addField("unsigned int frictionType", "frictionType", "u32",sizeof(PxFrictionType::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, frictionType));
        structGen.addField("unsigned int solverType", "solverType", "u32",sizeof(PxSolverType::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, solverType));
        structGen.addField("float bounceThresholdVelocity", "bounceThresholdVelocity", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSceneDesc_Pod, bounceThresholdVelocity));
        structGen.addField("float frictionOffsetThreshold", "frictionOffsetThreshold", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSceneDesc_Pod, frictionOffsetThreshold));
        structGen.addField("float ccdMaxSeparation", "ccdMaxSeparation", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSceneDesc_Pod, ccdMaxSeparation));
        structGen.addField("float solverOffsetSlop", "solverOffsetSlop", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSceneDesc_Pod, solverOffsetSlop));
        structGen.addField("physx_PxSceneFlags_Pod flags", "flags", "PxSceneFlags",sizeof(physx::PxSceneFlags), unsafe_offsetof(physx_PxSceneDesc_Pod, flags));
        structGen.addField("physx_PxCpuDispatcher_Pod* cpuDispatcher", "cpuDispatcher", "*mut PxCpuDispatcher",sizeof(physx::PxCpuDispatcher *), unsafe_offsetof(physx_PxSceneDesc_Pod, cpuDispatcher));
        structGen.addField("physx_PxCudaContextManager_Pod* cudaContextManager", "cudaContextManager", "*mut PxCudaContextManager",sizeof(physx::PxCudaContextManager *), unsafe_offsetof(physx_PxSceneDesc_Pod, cudaContextManager));
        structGen.addField("unsigned int staticStructure", "staticStructure", "u32",sizeof(PxPruningStructureType::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, staticStructure));
        structGen.addField("unsigned int dynamicStructure", "dynamicStructure", "u32",sizeof(PxPruningStructureType::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, dynamicStructure));
        structGen.addField("uint32_t dynamicTreeRebuildRateHint", "dynamicTreeRebuildRateHint", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneDesc_Pod, dynamicTreeRebuildRateHint));
        structGen.addField("unsigned int sceneQueryUpdateMode", "sceneQueryUpdateMode", "u32",sizeof(PxSceneQueryUpdateMode::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, sceneQueryUpdateMode));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxSceneDesc_Pod, userData));
        structGen.addField("uint32_t solverBatchSize", "solverBatchSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneDesc_Pod, solverBatchSize));
        structGen.addField("uint32_t solverArticulationBatchSize", "solverArticulationBatchSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneDesc_Pod, solverArticulationBatchSize));
        structGen.addField("uint32_t nbContactDataBlocks", "nbContactDataBlocks", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneDesc_Pod, nbContactDataBlocks));
        structGen.addField("uint32_t maxNbContactDataBlocks", "maxNbContactDataBlocks", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneDesc_Pod, maxNbContactDataBlocks));
        structGen.addField("float maxBiasCoefficient", "maxBiasCoefficient", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSceneDesc_Pod, maxBiasCoefficient));
        structGen.addField("uint32_t contactReportStreamBufferSize", "contactReportStreamBufferSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneDesc_Pod, contactReportStreamBufferSize));
        structGen.addField("uint32_t ccdMaxPasses", "ccdMaxPasses", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneDesc_Pod, ccdMaxPasses));
        structGen.addField("float ccdThreshold", "ccdThreshold", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSceneDesc_Pod, ccdThreshold));
        structGen.addField("float wakeCounterResetValue", "wakeCounterResetValue", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSceneDesc_Pod, wakeCounterResetValue));
        structGen.addField("physx_PxBounds3_Pod sanityBounds", "sanityBounds", "PxBounds3",sizeof(physx::PxBounds3), unsafe_offsetof(physx_PxSceneDesc_Pod, sanityBounds));
        structGen.addField("physx_PxgDynamicsMemoryConfig_Pod gpuDynamicsConfig", "gpuDynamicsConfig", "PxgDynamicsMemoryConfig",sizeof(physx::PxgDynamicsMemoryConfig), unsafe_offsetof(physx_PxSceneDesc_Pod, gpuDynamicsConfig));
        structGen.addField("uint32_t gpuMaxNumPartitions", "gpuMaxNumPartitions", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneDesc_Pod, gpuMaxNumPartitions));
        structGen.addField("uint32_t gpuComputeVersion", "gpuComputeVersion", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneDesc_Pod, gpuComputeVersion));
        structGen.endStruct(sizeof(physx::PxSceneDesc));
    }
};
physx_PxSceneDesc_Pod::dumpLayout(structGen);

struct physx_PxRigidStatic_Pod: public physx::PxRigidStatic {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxRigidStatic_Pod", "PxRigidStatic");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxRigidStatic_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxRigidStatic_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxRigidStatic_Pod, userData));
        structGen.endStruct(sizeof(physx::PxRigidStatic));
    }
};
physx_PxRigidStatic_Pod::dumpLayout(structGen);

struct physx_PxRigidDynamic_Pod: public physx::PxRigidDynamic {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxRigidDynamic_Pod", "PxRigidDynamic");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxRigidDynamic_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxRigidDynamic_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxRigidDynamic_Pod, userData));
        structGen.endStruct(sizeof(physx::PxRigidDynamic));
    }
};
physx_PxRigidDynamic_Pod::dumpLayout(structGen);

struct physx_PxPruningStructure_Pod: public physx::PxPruningStructure {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxPruningStructure_Pod", "PxPruningStructure");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxPruningStructure_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxPruningStructure_Pod, mBaseFlags));
        structGen.endStruct(sizeof(physx::PxPruningStructure));
    }
};
physx_PxPruningStructure_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxDeletionEventFlags_Pod {\n    unsigned char mBits;\n};\n");
structGen.passThroughC("struct physx_PxPvd_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxRigidDynamicLockFlags_Pod {\n    unsigned char mBits;\n};\n");
struct physx_PxSimulationStatistics_Pod: public physx::PxSimulationStatistics {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSimulationStatistics_Pod", "PxSimulationStatistics");
        structGen.addField("uint32_t nbActiveConstraints", "nbActiveConstraints", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbActiveConstraints));
        structGen.addField("uint32_t nbActiveDynamicBodies", "nbActiveDynamicBodies", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbActiveDynamicBodies));
        structGen.addField("uint32_t nbActiveKinematicBodies", "nbActiveKinematicBodies", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbActiveKinematicBodies));
        structGen.addField("uint32_t nbStaticBodies", "nbStaticBodies", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbStaticBodies));
        structGen.addField("uint32_t nbDynamicBodies", "nbDynamicBodies", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbDynamicBodies));
        structGen.addField("uint32_t nbKinematicBodies", "nbKinematicBodies", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbKinematicBodies));
        structGen.addField("uint32_t nbShapes[7]", "nbShapes", "[u32; 7]",sizeof(physx::PxU32[7]), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbShapes));
        structGen.addField("uint32_t nbAggregates", "nbAggregates", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbAggregates));
        structGen.addField("uint32_t nbArticulations", "nbArticulations", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbArticulations));
        structGen.addField("uint32_t nbAxisSolverConstraints", "nbAxisSolverConstraints", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbAxisSolverConstraints));
        structGen.addField("uint32_t compressedContactSize", "compressedContactSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, compressedContactSize));
        structGen.addField("uint32_t requiredContactConstraintMemory", "requiredContactConstraintMemory", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, requiredContactConstraintMemory));
        structGen.addField("uint32_t peakConstraintMemory", "peakConstraintMemory", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, peakConstraintMemory));
        structGen.addField("uint32_t nbDiscreteContactPairsTotal", "nbDiscreteContactPairsTotal", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbDiscreteContactPairsTotal));
        structGen.addField("uint32_t nbDiscreteContactPairsWithCacheHits", "nbDiscreteContactPairsWithCacheHits", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbDiscreteContactPairsWithCacheHits));
        structGen.addField("uint32_t nbDiscreteContactPairsWithContacts", "nbDiscreteContactPairsWithContacts", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbDiscreteContactPairsWithContacts));
        structGen.addField("uint32_t nbNewPairs", "nbNewPairs", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbNewPairs));
        structGen.addField("uint32_t nbLostPairs", "nbLostPairs", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbLostPairs));
        structGen.addField("uint32_t nbNewTouches", "nbNewTouches", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbNewTouches));
        structGen.addField("uint32_t nbLostTouches", "nbLostTouches", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbLostTouches));
        structGen.addField("uint32_t nbPartitions", "nbPartitions", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbPartitions));
        structGen.addField("uint32_t nbBroadPhaseAdds", "nbBroadPhaseAdds", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbBroadPhaseAdds));
        structGen.addField("uint32_t nbBroadPhaseRemoves", "nbBroadPhaseRemoves", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbBroadPhaseRemoves));
        structGen.addField("uint32_t nbDiscreteContactPairs[7][7]", "nbDiscreteContactPairs", "[[u32; 7]; 7]",sizeof(physx::PxU32[7][7]), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbDiscreteContactPairs));
        structGen.addField("uint32_t nbCCDPairs[7][7]", "nbCCDPairs", "[[u32; 7]; 7]",sizeof(physx::PxU32[7][7]), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbCCDPairs));
        structGen.addField("uint32_t nbModifiedContactPairs[7][7]", "nbModifiedContactPairs", "[[u32; 7]; 7]",sizeof(physx::PxU32[7][7]), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbModifiedContactPairs));
        structGen.addField("uint32_t nbTriggerPairs[7][7]", "nbTriggerPairs", "[[u32; 7]; 7]",sizeof(physx::PxU32[7][7]), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbTriggerPairs));
        structGen.endStruct(sizeof(physx::PxSimulationStatistics));
    }
};
physx_PxSimulationStatistics_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxPvdSceneClient_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxPvdSceneFlags_Pod {\n    unsigned char mBits;\n};\n");
structGen.passThroughC("struct physx_pvdsdk_PvdDebugPoint_Pod;\n");
structGen.passThroughC("struct physx_pvdsdk_PvdDebugLine_Pod;\n");
structGen.passThroughC("struct physx_pvdsdk_PvdDebugTriangle_Pod;\n");
structGen.passThroughC("struct physx_pvdsdk_PvdDebugText_Pod;\n");
structGen.passThroughC("struct physx_pvdsdk_PvdClient_Pod;\n");
struct physx_PxDominanceGroupPair_Pod: public physx::PxDominanceGroupPair {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxDominanceGroupPair_Pod", "PxDominanceGroupPair");
        structGen.addField("unsigned char dominance0", "dominance0", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxDominanceGroupPair_Pod, dominance0));
        structGen.addField("unsigned char dominance1", "dominance1", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxDominanceGroupPair_Pod, dominance1));
        structGen.endStruct(sizeof(physx::PxDominanceGroupPair));
    }
};
physx_PxDominanceGroupPair_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxActorTypeFlags_Pod {\n    uint16_t mBits;\n};\n");
structGen.passThroughC("struct physx_PxContactPairHeaderFlags_Pod {\n    uint16_t mBits;\n};\n");
structGen.passThroughC("struct physx_PxContactPairFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxContactPair_Pod: public physx::PxContactPair {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactPair_Pod", "PxContactPair");
        structGen.addField("physx_PxShape_Pod* shapes[2]", "shapes", "[*mut PxShape; 2]",sizeof(physx::PxShape *[2]), unsafe_offsetof(physx_PxContactPair_Pod, shapes));
        structGen.addField("unsigned char* contactPatches", "contactPatches", "*const u8",sizeof(const physx::PxU8 *), unsafe_offsetof(physx_PxContactPair_Pod, contactPatches));
        structGen.addField("unsigned char* contactPoints", "contactPoints", "*const u8",sizeof(const physx::PxU8 *), unsafe_offsetof(physx_PxContactPair_Pod, contactPoints));
        structGen.addField("float* contactImpulses", "contactImpulses", "*const f32",sizeof(const physx::PxReal *), unsafe_offsetof(physx_PxContactPair_Pod, contactImpulses));
        structGen.addField("uint32_t requiredBufferSize", "requiredBufferSize", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactPair_Pod, requiredBufferSize));
        structGen.addField("unsigned char contactCount", "contactCount", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxContactPair_Pod, contactCount));
        structGen.addField("unsigned char patchCount", "patchCount", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxContactPair_Pod, patchCount));
        structGen.addField("uint16_t contactStreamSize", "contactStreamSize", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxContactPair_Pod, contactStreamSize));
        structGen.addField("physx_PxContactPairFlags_Pod flags", "flags", "PxContactPairFlags",sizeof(physx::PxContactPairFlags), unsafe_offsetof(physx_PxContactPair_Pod, flags));
        structGen.addField("physx_PxPairFlags_Pod events", "events", "PxPairFlags",sizeof(physx::PxPairFlags), unsafe_offsetof(physx_PxContactPair_Pod, events));
        structGen.addField("uint32_t internalData[2]", "internalData", "[u32; 2]",sizeof(physx::PxU32[2]), unsafe_offsetof(physx_PxContactPair_Pod, internalData));
        structGen.endStruct(sizeof(physx::PxContactPair));
    }
};
physx_PxContactPair_Pod::dumpLayout(structGen);

struct physx_PxContactPairHeader_Pod: public physx::PxContactPairHeader {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactPairHeader_Pod", "PxContactPairHeader");
        structGen.addField("physx_PxRigidActor_Pod* actors[2]", "actors", "[*mut PxRigidActor; 2]",sizeof(physx::PxRigidActor *[2]), unsafe_offsetof(physx_PxContactPairHeader_Pod, actors));
        structGen.addField("unsigned char* extraDataStream", "extraDataStream", "*const u8",sizeof(const physx::PxU8 *), unsafe_offsetof(physx_PxContactPairHeader_Pod, extraDataStream));
        structGen.addField("uint16_t extraDataStreamSize", "extraDataStreamSize", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxContactPairHeader_Pod, extraDataStreamSize));
        structGen.addField("physx_PxContactPairHeaderFlags_Pod flags", "flags", "PxContactPairHeaderFlags",sizeof(physx::PxContactPairHeaderFlags), unsafe_offsetof(physx_PxContactPairHeader_Pod, flags));
        structGen.addField("physx_PxContactPair_Pod* pairs", "pairs", "*const PxContactPair",sizeof(const struct PxContactPair *), unsafe_offsetof(physx_PxContactPairHeader_Pod, pairs));
        structGen.addField("uint32_t nbPairs", "nbPairs", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactPairHeader_Pod, nbPairs));
        structGen.endStruct(sizeof(physx::PxContactPairHeader));
    }
};
physx_PxContactPairHeader_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxRaycastCallback_Pod {\n    void* vtable_;\n    physx_PxRaycastHit_Pod block;\n    bool hasBlock;\n    physx_PxRaycastHit_Pod* touches;\n    uint32_t maxNbTouches;\n    uint32_t nbTouches;\n};\n");
structGen.passThroughC("struct physx_PxSweepCallback_Pod {\n    void* vtable_;\n    physx_PxSweepHit_Pod block;\n    bool hasBlock;\n    physx_PxSweepHit_Pod* touches;\n    uint32_t maxNbTouches;\n    uint32_t nbTouches;\n};\n");
structGen.passThroughC("struct physx_PxOverlapCallback_Pod {\n    void* vtable_;\n    physx_PxOverlapHit_Pod block;\n    bool hasBlock;\n    physx_PxOverlapHit_Pod* touches;\n    uint32_t maxNbTouches;\n    uint32_t nbTouches;\n};\n");
struct physx_PxBroadPhaseCaps_Pod: public physx::PxBroadPhaseCaps {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBroadPhaseCaps_Pod", "PxBroadPhaseCaps");
        structGen.addField("uint32_t maxNbRegions", "maxNbRegions", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBroadPhaseCaps_Pod, maxNbRegions));
        structGen.addField("uint32_t maxNbObjects", "maxNbObjects", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBroadPhaseCaps_Pod, maxNbObjects));
        structGen.addField("bool needsPredefinedBounds", "needsPredefinedBounds", "bool",sizeof(bool), unsafe_offsetof(physx_PxBroadPhaseCaps_Pod, needsPredefinedBounds));
        structGen.endStruct(sizeof(physx::PxBroadPhaseCaps));
    }
};
physx_PxBroadPhaseCaps_Pod::dumpLayout(structGen);

struct physx_PxBroadPhaseRegion_Pod: public physx::PxBroadPhaseRegion {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBroadPhaseRegion_Pod", "PxBroadPhaseRegion");
        structGen.addField("physx_PxBounds3_Pod bounds", "bounds", "PxBounds3",sizeof(physx::PxBounds3), unsafe_offsetof(physx_PxBroadPhaseRegion_Pod, bounds));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxBroadPhaseRegion_Pod, userData));
        structGen.endStruct(sizeof(physx::PxBroadPhaseRegion));
    }
};
physx_PxBroadPhaseRegion_Pod::dumpLayout(structGen);

struct physx_PxBroadPhaseRegionInfo_Pod: public physx::PxBroadPhaseRegionInfo {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBroadPhaseRegionInfo_Pod", "PxBroadPhaseRegionInfo");
        structGen.addField("physx_PxBroadPhaseRegion_Pod region", "region", "PxBroadPhaseRegion",sizeof(physx::PxBroadPhaseRegion), unsafe_offsetof(physx_PxBroadPhaseRegionInfo_Pod, region));
        structGen.addField("uint32_t nbStaticObjects", "nbStaticObjects", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBroadPhaseRegionInfo_Pod, nbStaticObjects));
        structGen.addField("uint32_t nbDynamicObjects", "nbDynamicObjects", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBroadPhaseRegionInfo_Pod, nbDynamicObjects));
        structGen.addField("bool active", "active", "bool",sizeof(bool), unsafe_offsetof(physx_PxBroadPhaseRegionInfo_Pod, active));
        structGen.addField("bool overlap", "overlap", "bool",sizeof(bool), unsafe_offsetof(physx_PxBroadPhaseRegionInfo_Pod, overlap));
        structGen.endStruct(sizeof(physx::PxBroadPhaseRegionInfo));
    }
};
physx_PxBroadPhaseRegionInfo_Pod::dumpLayout(structGen);

struct physx_PxSceneReadLock_Pod: public physx::PxSceneReadLock {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSceneReadLock_Pod", "PxSceneReadLock");
        structGen.endStruct(sizeof(physx::PxSceneReadLock));
    }
};
physx_PxSceneReadLock_Pod::dumpLayout(structGen);

struct physx_PxSceneWriteLock_Pod: public physx::PxSceneWriteLock {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSceneWriteLock_Pod", "PxSceneWriteLock");
        structGen.endStruct(sizeof(physx::PxSceneWriteLock));
    }
};
physx_PxSceneWriteLock_Pod::dumpLayout(structGen);

struct physx_PxContactPairExtraDataItem_Pod: public physx::PxContactPairExtraDataItem {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactPairExtraDataItem_Pod", "PxContactPairExtraDataItem");
        structGen.addField("unsigned char type", "_type", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxContactPairExtraDataItem_Pod, type));
        structGen.endStruct(sizeof(physx::PxContactPairExtraDataItem));
    }
};
physx_PxContactPairExtraDataItem_Pod::dumpLayout(structGen);

struct physx_PxContactPairVelocity_Pod: public physx::PxContactPairVelocity {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactPairVelocity_Pod", "PxContactPairVelocity");
        structGen.addField("unsigned char type", "_type", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxContactPairVelocity_Pod, type));
        structGen.addField("physx_PxVec3_Pod linearVelocity[2]", "linearVelocity", "[PxVec3; 2]",sizeof(physx::PxVec3[2]), unsafe_offsetof(physx_PxContactPairVelocity_Pod, linearVelocity));
        structGen.addField("physx_PxVec3_Pod angularVelocity[2]", "angularVelocity", "[PxVec3; 2]",sizeof(physx::PxVec3[2]), unsafe_offsetof(physx_PxContactPairVelocity_Pod, angularVelocity));
        structGen.endStruct(sizeof(physx::PxContactPairVelocity));
    }
};
physx_PxContactPairVelocity_Pod::dumpLayout(structGen);

struct physx_PxContactPairPose_Pod: public physx::PxContactPairPose {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactPairPose_Pod", "PxContactPairPose");
        structGen.addField("unsigned char type", "_type", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxContactPairPose_Pod, type));
        structGen.addField("physx_PxTransform_Pod globalPose[2]", "globalPose", "[PxTransform; 2]",sizeof(physx::PxTransform[2]), unsafe_offsetof(physx_PxContactPairPose_Pod, globalPose));
        structGen.endStruct(sizeof(physx::PxContactPairPose));
    }
};
physx_PxContactPairPose_Pod::dumpLayout(structGen);

struct physx_PxContactPairIndex_Pod: public physx::PxContactPairIndex {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactPairIndex_Pod", "PxContactPairIndex");
        structGen.addField("unsigned char type", "_type", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxContactPairIndex_Pod, type));
        structGen.addField("uint16_t index", "index", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxContactPairIndex_Pod, index));
        structGen.endStruct(sizeof(physx::PxContactPairIndex));
    }
};
physx_PxContactPairIndex_Pod::dumpLayout(structGen);

struct physx_PxContactPairExtraDataIterator_Pod: public physx::PxContactPairExtraDataIterator {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactPairExtraDataIterator_Pod", "PxContactPairExtraDataIterator");
        structGen.addField("unsigned char* currPtr", "currPtr", "*const u8",sizeof(const physx::PxU8 *), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, currPtr));
        structGen.addField("unsigned char* endPtr", "endPtr", "*const u8",sizeof(const physx::PxU8 *), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, endPtr));
        structGen.addField("physx_PxContactPairVelocity_Pod* preSolverVelocity", "preSolverVelocity", "*const PxContactPairVelocity",sizeof(const physx::PxContactPairVelocity *), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, preSolverVelocity));
        structGen.addField("physx_PxContactPairVelocity_Pod* postSolverVelocity", "postSolverVelocity", "*const PxContactPairVelocity",sizeof(const physx::PxContactPairVelocity *), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, postSolverVelocity));
        structGen.addField("physx_PxContactPairPose_Pod* eventPose", "eventPose", "*const PxContactPairPose",sizeof(const physx::PxContactPairPose *), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, eventPose));
        structGen.addField("uint32_t contactPairIndex", "contactPairIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, contactPairIndex));
        structGen.endStruct(sizeof(physx::PxContactPairExtraDataIterator));
    }
};
physx_PxContactPairExtraDataIterator_Pod::dumpLayout(structGen);

struct physx_PxContactPairPoint_Pod: public physx::PxContactPairPoint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactPairPoint_Pod", "PxContactPairPoint");
        structGen.addField("physx_PxVec3_Pod position", "position", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactPairPoint_Pod, position));
        structGen.addField("float separation", "separation", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxContactPairPoint_Pod, separation));
        structGen.addField("physx_PxVec3_Pod normal", "normal", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactPairPoint_Pod, normal));
        structGen.addField("uint32_t internalFaceIndex0", "internalFaceIndex0", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactPairPoint_Pod, internalFaceIndex0));
        structGen.addField("physx_PxVec3_Pod impulse", "impulse", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactPairPoint_Pod, impulse));
        structGen.addField("uint32_t internalFaceIndex1", "internalFaceIndex1", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxContactPairPoint_Pod, internalFaceIndex1));
        structGen.endStruct(sizeof(physx::PxContactPairPoint));
    }
};
physx_PxContactPairPoint_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxTriggerPairFlags_Pod {\n    unsigned char mBits;\n};\n");
struct physx_PxTriggerPair_Pod: public physx::PxTriggerPair {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxTriggerPair_Pod", "PxTriggerPair");
        structGen.addField("physx_PxShape_Pod* triggerShape", "triggerShape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxTriggerPair_Pod, triggerShape));
        structGen.addField("physx_PxRigidActor_Pod* triggerActor", "triggerActor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxTriggerPair_Pod, triggerActor));
        structGen.addField("physx_PxShape_Pod* otherShape", "otherShape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxTriggerPair_Pod, otherShape));
        structGen.addField("physx_PxRigidActor_Pod* otherActor", "otherActor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxTriggerPair_Pod, otherActor));
        structGen.addField("unsigned int status", "status", "u32",sizeof(PxPairFlag::Enum), unsafe_offsetof(physx_PxTriggerPair_Pod, status));
        structGen.addField("physx_PxTriggerPairFlags_Pod flags", "flags", "PxTriggerPairFlags",sizeof(physx::PxTriggerPairFlags), unsafe_offsetof(physx_PxTriggerPair_Pod, flags));
        structGen.endStruct(sizeof(physx::PxTriggerPair));
    }
};
physx_PxTriggerPair_Pod::dumpLayout(structGen);

struct physx_PxConstraintInfo_Pod: public physx::PxConstraintInfo {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxConstraintInfo_Pod", "PxConstraintInfo");
        structGen.addField("physx_PxConstraint_Pod* constraint", "constraint", "*mut PxConstraint",sizeof(physx::PxConstraint *), unsafe_offsetof(physx_PxConstraintInfo_Pod, constraint));
        structGen.addField("void* externalReference", "externalReference", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxConstraintInfo_Pod, externalReference));
        structGen.addField("uint32_t type", "_type", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxConstraintInfo_Pod, type));
        structGen.endStruct(sizeof(physx::PxConstraintInfo));
    }
};
physx_PxConstraintInfo_Pod::dumpLayout(structGen);

struct physx_PxExtendedVec3_Pod: public physx::PxExtendedVec3 {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxExtendedVec3_Pod", "PxExtendedVec3");
        structGen.addField("double x", "x", "f64",sizeof(physx::PxExtended), unsafe_offsetof(physx_PxExtendedVec3_Pod, x));
        structGen.addField("double y", "y", "f64",sizeof(physx::PxExtended), unsafe_offsetof(physx_PxExtendedVec3_Pod, y));
        structGen.addField("double z", "z", "f64",sizeof(physx::PxExtended), unsafe_offsetof(physx_PxExtendedVec3_Pod, z));
        structGen.endStruct(sizeof(physx::PxExtendedVec3));
    }
};
physx_PxExtendedVec3_Pod::dumpLayout(structGen);

struct physx_PxObstacle_Pod: public physx::PxObstacle {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxObstacle_Pod", "PxObstacle");
        structGen.addField("int mType", "mType", "i32",sizeof(PxGeometryType::Enum), unsafe_offsetof(physx_PxObstacle_Pod, mType));
        structGen.addField("void* mUserData", "mUserData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxObstacle_Pod, mUserData));
        structGen.addField("physx_PxExtendedVec3_Pod mPos", "mPos", "PxExtendedVec3",sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxObstacle_Pod, mPos));
        structGen.addField("physx_PxQuat_Pod mRot", "mRot", "PxQuat",sizeof(physx::PxQuat), unsafe_offsetof(physx_PxObstacle_Pod, mRot));
        structGen.endStruct(sizeof(physx::PxObstacle));
    }
};
physx_PxObstacle_Pod::dumpLayout(structGen);

struct physx_PxBoxObstacle_Pod: public physx::PxBoxObstacle {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBoxObstacle_Pod", "PxBoxObstacle");
        structGen.addField("int mType", "mType", "i32",sizeof(PxGeometryType::Enum), unsafe_offsetof(physx_PxBoxObstacle_Pod, mType));
        structGen.addField("void* mUserData", "mUserData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxBoxObstacle_Pod, mUserData));
        structGen.addField("physx_PxExtendedVec3_Pod mPos", "mPos", "PxExtendedVec3",sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxBoxObstacle_Pod, mPos));
        structGen.addField("physx_PxQuat_Pod mRot", "mRot", "PxQuat",sizeof(physx::PxQuat), unsafe_offsetof(physx_PxBoxObstacle_Pod, mRot));
        structGen.addField("physx_PxVec3_Pod mHalfExtents", "mHalfExtents", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxBoxObstacle_Pod, mHalfExtents));
        structGen.endStruct(sizeof(physx::PxBoxObstacle));
    }
};
physx_PxBoxObstacle_Pod::dumpLayout(structGen);

struct physx_PxCapsuleObstacle_Pod: public physx::PxCapsuleObstacle {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxCapsuleObstacle_Pod", "PxCapsuleObstacle");
        structGen.addField("int mType", "mType", "i32",sizeof(PxGeometryType::Enum), unsafe_offsetof(physx_PxCapsuleObstacle_Pod, mType));
        structGen.addField("void* mUserData", "mUserData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxCapsuleObstacle_Pod, mUserData));
        structGen.addField("physx_PxExtendedVec3_Pod mPos", "mPos", "PxExtendedVec3",sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxCapsuleObstacle_Pod, mPos));
        structGen.addField("physx_PxQuat_Pod mRot", "mRot", "PxQuat",sizeof(physx::PxQuat), unsafe_offsetof(physx_PxCapsuleObstacle_Pod, mRot));
        structGen.addField("float mHalfHeight", "mHalfHeight", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxCapsuleObstacle_Pod, mHalfHeight));
        structGen.addField("float mRadius", "mRadius", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxCapsuleObstacle_Pod, mRadius));
        structGen.endStruct(sizeof(physx::PxCapsuleObstacle));
    }
};
physx_PxCapsuleObstacle_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxObstacleContext_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxControllerManager_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxUserControllerHitReport_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxController_Pod {\n    void* vtable_;\n};\n");
struct physx_PxControllerShapeHit_Pod: public physx::PxControllerShapeHit {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxControllerShapeHit_Pod", "PxControllerShapeHit");
        structGen.addField("physx_PxController_Pod* controller", "controller", "*mut PxController",sizeof(physx::PxController *), unsafe_offsetof(physx_PxControllerShapeHit_Pod, controller));
        structGen.addField("physx_PxExtendedVec3_Pod worldPos", "worldPos", "PxExtendedVec3",sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxControllerShapeHit_Pod, worldPos));
        structGen.addField("physx_PxVec3_Pod worldNormal", "worldNormal", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerShapeHit_Pod, worldNormal));
        structGen.addField("physx_PxVec3_Pod dir", "dir", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerShapeHit_Pod, dir));
        structGen.addField("float length", "length", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxControllerShapeHit_Pod, length));
        structGen.addField("physx_PxShape_Pod* shape", "shape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxControllerShapeHit_Pod, shape));
        structGen.addField("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxControllerShapeHit_Pod, actor));
        structGen.addField("uint32_t triangleIndex", "triangleIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxControllerShapeHit_Pod, triangleIndex));
        structGen.endStruct(sizeof(physx::PxControllerShapeHit));
    }
};
physx_PxControllerShapeHit_Pod::dumpLayout(structGen);

struct physx_PxControllersHit_Pod: public physx::PxControllersHit {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxControllersHit_Pod", "PxControllersHit");
        structGen.addField("physx_PxController_Pod* controller", "controller", "*mut PxController",sizeof(physx::PxController *), unsafe_offsetof(physx_PxControllersHit_Pod, controller));
        structGen.addField("physx_PxExtendedVec3_Pod worldPos", "worldPos", "PxExtendedVec3",sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxControllersHit_Pod, worldPos));
        structGen.addField("physx_PxVec3_Pod worldNormal", "worldNormal", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllersHit_Pod, worldNormal));
        structGen.addField("physx_PxVec3_Pod dir", "dir", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllersHit_Pod, dir));
        structGen.addField("float length", "length", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxControllersHit_Pod, length));
        structGen.addField("physx_PxController_Pod* other", "other", "*mut PxController",sizeof(physx::PxController *), unsafe_offsetof(physx_PxControllersHit_Pod, other));
        structGen.endStruct(sizeof(physx::PxControllersHit));
    }
};
physx_PxControllersHit_Pod::dumpLayout(structGen);

struct physx_PxControllerObstacleHit_Pod: public physx::PxControllerObstacleHit {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxControllerObstacleHit_Pod", "PxControllerObstacleHit");
        structGen.addField("physx_PxController_Pod* controller", "controller", "*mut PxController",sizeof(physx::PxController *), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, controller));
        structGen.addField("physx_PxExtendedVec3_Pod worldPos", "worldPos", "PxExtendedVec3",sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, worldPos));
        structGen.addField("physx_PxVec3_Pod worldNormal", "worldNormal", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, worldNormal));
        structGen.addField("physx_PxVec3_Pod dir", "dir", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, dir));
        structGen.addField("float length", "length", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, length));
        structGen.addField("void* userData", "userData", "*const std::ffi::c_void",sizeof(const void *), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, userData));
        structGen.endStruct(sizeof(physx::PxControllerObstacleHit));
    }
};
physx_PxControllerObstacleHit_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxControllerFilterCallback_Pod {\n    void* vtable_;\n};\n");
struct physx_PxControllerFilters_Pod: public physx::PxControllerFilters {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxControllerFilters_Pod", "PxControllerFilters");
        structGen.addField("physx_PxFilterData_Pod* mFilterData", "mFilterData", "*const PxFilterData",sizeof(const physx::PxFilterData *), unsafe_offsetof(physx_PxControllerFilters_Pod, mFilterData));
        structGen.addField("physx_PxQueryFilterCallback_Pod* mFilterCallback", "mFilterCallback", "*mut PxQueryFilterCallback",sizeof(physx::PxQueryFilterCallback *), unsafe_offsetof(physx_PxControllerFilters_Pod, mFilterCallback));
        structGen.addField("physx_PxQueryFlags_Pod mFilterFlags", "mFilterFlags", "PxQueryFlags",sizeof(physx::PxQueryFlags), unsafe_offsetof(physx_PxControllerFilters_Pod, mFilterFlags));
        structGen.addField("physx_PxControllerFilterCallback_Pod* mCCTFilterCallback", "mCCTFilterCallback", "*mut PxControllerFilterCallback",sizeof(physx::PxControllerFilterCallback *), unsafe_offsetof(physx_PxControllerFilters_Pod, mCCTFilterCallback));
        structGen.endStruct(sizeof(physx::PxControllerFilters));
    }
};
physx_PxControllerFilters_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxControllerBehaviorCallback_Pod {\n    void* vtable_;\n};\n");
struct physx_PxControllerDesc_Pod: public physx::PxControllerDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxControllerDesc_Pod", "PxControllerDesc");
        structGen.addField("physx_PxExtendedVec3_Pod position", "position", "PxExtendedVec3",sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxControllerDesc_Pod, position));
        structGen.addField("physx_PxVec3_Pod upDirection", "upDirection", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerDesc_Pod, upDirection));
        structGen.addField("float slopeLimit", "slopeLimit", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxControllerDesc_Pod, slopeLimit));
        structGen.addField("float invisibleWallHeight", "invisibleWallHeight", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxControllerDesc_Pod, invisibleWallHeight));
        structGen.addField("float maxJumpHeight", "maxJumpHeight", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxControllerDesc_Pod, maxJumpHeight));
        structGen.addField("float contactOffset", "contactOffset", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxControllerDesc_Pod, contactOffset));
        structGen.addField("float stepOffset", "stepOffset", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxControllerDesc_Pod, stepOffset));
        structGen.addField("float density", "density", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxControllerDesc_Pod, density));
        structGen.addField("float scaleCoeff", "scaleCoeff", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxControllerDesc_Pod, scaleCoeff));
        structGen.addField("float volumeGrowth", "volumeGrowth", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxControllerDesc_Pod, volumeGrowth));
        structGen.addField("physx_PxUserControllerHitReport_Pod* reportCallback", "reportCallback", "*mut PxUserControllerHitReport",sizeof(physx::PxUserControllerHitReport *), unsafe_offsetof(physx_PxControllerDesc_Pod, reportCallback));
        structGen.addField("physx_PxControllerBehaviorCallback_Pod* behaviorCallback", "behaviorCallback", "*mut PxControllerBehaviorCallback",sizeof(physx::PxControllerBehaviorCallback *), unsafe_offsetof(physx_PxControllerDesc_Pod, behaviorCallback));
        structGen.addField("unsigned int nonWalkableMode", "nonWalkableMode", "u32",sizeof(PxControllerNonWalkableMode::Enum), unsafe_offsetof(physx_PxControllerDesc_Pod, nonWalkableMode));
        structGen.addField("physx_PxMaterial_Pod* material", "material", "*mut PxMaterial",sizeof(physx::PxMaterial *), unsafe_offsetof(physx_PxControllerDesc_Pod, material));
        structGen.addField("bool registerDeletionListener", "registerDeletionListener", "bool",sizeof(bool), unsafe_offsetof(physx_PxControllerDesc_Pod, registerDeletionListener));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxControllerDesc_Pod, userData));
        structGen.addField("unsigned int mType", "mType", "u32",sizeof(const PxControllerShapeType::Enum), unsafe_offsetof(physx_PxControllerDesc_Pod, mType));
        structGen.endStruct(sizeof(physx::PxControllerDesc));
    }
};
physx_PxControllerDesc_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxControllerCollisionFlags_Pod {\n    unsigned char mBits;\n};\n");
struct physx_PxControllerState_Pod: public physx::PxControllerState {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxControllerState_Pod", "PxControllerState");
        structGen.addField("physx_PxVec3_Pod deltaXP", "deltaXP", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerState_Pod, deltaXP));
        structGen.addField("physx_PxShape_Pod* touchedShape", "touchedShape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxControllerState_Pod, touchedShape));
        structGen.addField("physx_PxRigidActor_Pod* touchedActor", "touchedActor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxControllerState_Pod, touchedActor));
        structGen.addField("uint32_t touchedObstacleHandle", "touchedObstacleHandle", "u32",sizeof(physx::ObstacleHandle), unsafe_offsetof(physx_PxControllerState_Pod, touchedObstacleHandle));
        structGen.addField("uint32_t collisionFlags", "collisionFlags", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxControllerState_Pod, collisionFlags));
        structGen.addField("bool standOnAnotherCCT", "standOnAnotherCCT", "bool",sizeof(bool), unsafe_offsetof(physx_PxControllerState_Pod, standOnAnotherCCT));
        structGen.addField("bool standOnObstacle", "standOnObstacle", "bool",sizeof(bool), unsafe_offsetof(physx_PxControllerState_Pod, standOnObstacle));
        structGen.addField("bool isMovingUp", "isMovingUp", "bool",sizeof(bool), unsafe_offsetof(physx_PxControllerState_Pod, isMovingUp));
        structGen.endStruct(sizeof(physx::PxControllerState));
    }
};
physx_PxControllerState_Pod::dumpLayout(structGen);

struct physx_PxControllerStats_Pod: public physx::PxControllerStats {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxControllerStats_Pod", "PxControllerStats");
        structGen.addField("uint16_t nbIterations", "nbIterations", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxControllerStats_Pod, nbIterations));
        structGen.addField("uint16_t nbFullUpdates", "nbFullUpdates", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxControllerStats_Pod, nbFullUpdates));
        structGen.addField("uint16_t nbPartialUpdates", "nbPartialUpdates", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxControllerStats_Pod, nbPartialUpdates));
        structGen.addField("uint16_t nbTessellation", "nbTessellation", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxControllerStats_Pod, nbTessellation));
        structGen.endStruct(sizeof(physx::PxControllerStats));
    }
};
physx_PxControllerStats_Pod::dumpLayout(structGen);

struct physx_PxBoxControllerDesc_Pod: public physx::PxBoxControllerDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBoxControllerDesc_Pod", "PxBoxControllerDesc");
        structGen.addField("physx_PxExtendedVec3_Pod position", "position", "PxExtendedVec3",sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, position));
        structGen.addField("physx_PxVec3_Pod upDirection", "upDirection", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, upDirection));
        structGen.addField("float slopeLimit", "slopeLimit", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, slopeLimit));
        structGen.addField("float invisibleWallHeight", "invisibleWallHeight", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, invisibleWallHeight));
        structGen.addField("float maxJumpHeight", "maxJumpHeight", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, maxJumpHeight));
        structGen.addField("float contactOffset", "contactOffset", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, contactOffset));
        structGen.addField("float stepOffset", "stepOffset", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, stepOffset));
        structGen.addField("float density", "density", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, density));
        structGen.addField("float scaleCoeff", "scaleCoeff", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, scaleCoeff));
        structGen.addField("float volumeGrowth", "volumeGrowth", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, volumeGrowth));
        structGen.addField("physx_PxUserControllerHitReport_Pod* reportCallback", "reportCallback", "*mut PxUserControllerHitReport",sizeof(physx::PxUserControllerHitReport *), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, reportCallback));
        structGen.addField("physx_PxControllerBehaviorCallback_Pod* behaviorCallback", "behaviorCallback", "*mut PxControllerBehaviorCallback",sizeof(physx::PxControllerBehaviorCallback *), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, behaviorCallback));
        structGen.addField("unsigned int nonWalkableMode", "nonWalkableMode", "u32",sizeof(PxControllerNonWalkableMode::Enum), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, nonWalkableMode));
        structGen.addField("physx_PxMaterial_Pod* material", "material", "*mut PxMaterial",sizeof(physx::PxMaterial *), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, material));
        structGen.addField("bool registerDeletionListener", "registerDeletionListener", "bool",sizeof(bool), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, registerDeletionListener));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, userData));
        structGen.addField("unsigned int mType", "mType", "u32",sizeof(const PxControllerShapeType::Enum), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, mType));
        structGen.addField("float halfHeight", "halfHeight", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, halfHeight));
        structGen.addField("float halfSideExtent", "halfSideExtent", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, halfSideExtent));
        structGen.addField("float halfForwardExtent", "halfForwardExtent", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, halfForwardExtent));
        structGen.endStruct(sizeof(physx::PxBoxControllerDesc));
    }
};
physx_PxBoxControllerDesc_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxBoxController_Pod {\n    void* vtable_;\n};\n");
struct physx_PxCapsuleControllerDesc_Pod: public physx::PxCapsuleControllerDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxCapsuleControllerDesc_Pod", "PxCapsuleControllerDesc");
        structGen.addField("physx_PxExtendedVec3_Pod position", "position", "PxExtendedVec3",sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, position));
        structGen.addField("physx_PxVec3_Pod upDirection", "upDirection", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, upDirection));
        structGen.addField("float slopeLimit", "slopeLimit", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, slopeLimit));
        structGen.addField("float invisibleWallHeight", "invisibleWallHeight", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, invisibleWallHeight));
        structGen.addField("float maxJumpHeight", "maxJumpHeight", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, maxJumpHeight));
        structGen.addField("float contactOffset", "contactOffset", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, contactOffset));
        structGen.addField("float stepOffset", "stepOffset", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, stepOffset));
        structGen.addField("float density", "density", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, density));
        structGen.addField("float scaleCoeff", "scaleCoeff", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, scaleCoeff));
        structGen.addField("float volumeGrowth", "volumeGrowth", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, volumeGrowth));
        structGen.addField("physx_PxUserControllerHitReport_Pod* reportCallback", "reportCallback", "*mut PxUserControllerHitReport",sizeof(physx::PxUserControllerHitReport *), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, reportCallback));
        structGen.addField("physx_PxControllerBehaviorCallback_Pod* behaviorCallback", "behaviorCallback", "*mut PxControllerBehaviorCallback",sizeof(physx::PxControllerBehaviorCallback *), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, behaviorCallback));
        structGen.addField("unsigned int nonWalkableMode", "nonWalkableMode", "u32",sizeof(PxControllerNonWalkableMode::Enum), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, nonWalkableMode));
        structGen.addField("physx_PxMaterial_Pod* material", "material", "*mut PxMaterial",sizeof(physx::PxMaterial *), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, material));
        structGen.addField("bool registerDeletionListener", "registerDeletionListener", "bool",sizeof(bool), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, registerDeletionListener));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, userData));
        structGen.addField("unsigned int mType", "mType", "u32",sizeof(const PxControllerShapeType::Enum), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, mType));
        structGen.addField("float radius", "radius", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, radius));
        structGen.addField("float height", "height", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, height));
        structGen.addField("unsigned int climbingMode", "climbingMode", "u32",sizeof(PxCapsuleClimbingMode::Enum), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, climbingMode));
        structGen.endStruct(sizeof(physx::PxCapsuleControllerDesc));
    }
};
physx_PxCapsuleControllerDesc_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxCapsuleController_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxControllerBehaviorFlags_Pod {\n    unsigned char mBits;\n};\n");
structGen.passThroughC("struct physx_PxControllerDebugRenderFlags_Pod {\n    uint32_t mBits;\n};\n");
structGen.passThroughC("struct physx_PxConvexFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxConvexMeshDesc_Pod: public physx::PxConvexMeshDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxConvexMeshDesc_Pod", "PxConvexMeshDesc");
        structGen.addField("physx_PxBoundedData_Pod points", "points", "PxBoundedData",sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, points));
        structGen.addField("physx_PxBoundedData_Pod polygons", "polygons", "PxBoundedData",sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, polygons));
        structGen.addField("physx_PxBoundedData_Pod indices", "indices", "PxBoundedData",sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, indices));
        structGen.addField("physx_PxConvexFlags_Pod flags", "flags", "PxConvexFlags",sizeof(physx::PxConvexFlags), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, flags));
        structGen.addField("uint16_t vertexLimit", "vertexLimit", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, vertexLimit));
        structGen.addField("uint16_t quantizedCount", "quantizedCount", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, quantizedCount));
        structGen.endStruct(sizeof(physx::PxConvexMeshDesc));
    }
};
physx_PxConvexMeshDesc_Pod::dumpLayout(structGen);

structGen.passThroughC("struct PxTypedStridedData_physx_PxMaterialTableIndex__Pod {\n    uint32_t stride;\n    uint16_t* data;\n};\n");
struct physx_PxTriangleMeshDesc_Pod: public physx::PxTriangleMeshDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxTriangleMeshDesc_Pod", "PxTriangleMeshDesc");
        structGen.addField("physx_PxBoundedData_Pod points", "points", "PxBoundedData",sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxTriangleMeshDesc_Pod, points));
        structGen.addField("physx_PxBoundedData_Pod triangles", "triangles", "PxBoundedData",sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxTriangleMeshDesc_Pod, triangles));
        structGen.addField("physx_PxMeshFlags_Pod flags", "flags", "PxMeshFlags",sizeof(physx::PxMeshFlags), unsafe_offsetof(physx_PxTriangleMeshDesc_Pod, flags));
        structGen.addField("PxTypedStridedData_physx_PxMaterialTableIndex__Pod materialIndices", "materialIndices", "PxTypedStridedData_physx_PxMaterialTableIndex_",sizeof(PxTypedStridedData<physx::PxMaterialTableIndex>), unsafe_offsetof(physx_PxTriangleMeshDesc_Pod, materialIndices));
        structGen.endStruct(sizeof(physx::PxTriangleMeshDesc));
    }
};
physx_PxTriangleMeshDesc_Pod::dumpLayout(structGen);

struct physx_PxBVH33MidphaseDesc_Pod: public physx::PxBVH33MidphaseDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBVH33MidphaseDesc_Pod", "PxBVH33MidphaseDesc");
        structGen.addField("float meshSizePerformanceTradeOff", "meshSizePerformanceTradeOff", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxBVH33MidphaseDesc_Pod, meshSizePerformanceTradeOff));
        structGen.addField("unsigned int meshCookingHint", "meshCookingHint", "u32",sizeof(PxMeshCookingHint::Enum), unsafe_offsetof(physx_PxBVH33MidphaseDesc_Pod, meshCookingHint));
        structGen.endStruct(sizeof(physx::PxBVH33MidphaseDesc));
    }
};
physx_PxBVH33MidphaseDesc_Pod::dumpLayout(structGen);

struct physx_PxBVH34MidphaseDesc_Pod: public physx::PxBVH34MidphaseDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBVH34MidphaseDesc_Pod", "PxBVH34MidphaseDesc");
        structGen.addField("uint32_t numPrimsPerLeaf", "numPrimsPerLeaf", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxBVH34MidphaseDesc_Pod, numPrimsPerLeaf));
        structGen.endStruct(sizeof(physx::PxBVH34MidphaseDesc));
    }
};
physx_PxBVH34MidphaseDesc_Pod::dumpLayout(structGen);

structGen.passThroughC("struct Anonymous217_Pod {\n    physx_PxBVH33MidphaseDesc_Pod mBVH33Desc;\n    physx_PxBVH34MidphaseDesc_Pod mBVH34Desc;\n};\n");
struct physx_PxMidphaseDesc_Pod: public physx::PxMidphaseDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxMidphaseDesc_Pod", "PxMidphaseDesc");
        structGen.addField("unsigned int mType", "mType", "u32",sizeof(PxMeshMidPhase::Enum), unsafe_offsetof(physx_PxMidphaseDesc_Pod, mType));
        structGen.endStruct(sizeof(physx::PxMidphaseDesc));
    }
};
physx_PxMidphaseDesc_Pod::dumpLayout(structGen);

struct physx_PxBVHStructureDesc_Pod: public physx::PxBVHStructureDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxBVHStructureDesc_Pod", "PxBVHStructureDesc");
        structGen.addField("physx_PxBoundedData_Pod bounds", "bounds", "PxBoundedData",sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxBVHStructureDesc_Pod, bounds));
        structGen.endStruct(sizeof(physx::PxBVHStructureDesc));
    }
};
physx_PxBVHStructureDesc_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxMeshPreprocessingFlags_Pod {\n    uint32_t mBits;\n};\n");
struct physx_PxCookingParams_Pod: public physx::PxCookingParams {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxCookingParams_Pod", "PxCookingParams");
        structGen.addField("float areaTestEpsilon", "areaTestEpsilon", "f32",sizeof(float), unsafe_offsetof(physx_PxCookingParams_Pod, areaTestEpsilon));
        structGen.addField("float planeTolerance", "planeTolerance", "f32",sizeof(float), unsafe_offsetof(physx_PxCookingParams_Pod, planeTolerance));
        structGen.addField("unsigned int convexMeshCookingType", "convexMeshCookingType", "u32",sizeof(PxConvexMeshCookingType::Enum), unsafe_offsetof(physx_PxCookingParams_Pod, convexMeshCookingType));
        structGen.addField("bool suppressTriangleMeshRemapTable", "suppressTriangleMeshRemapTable", "bool",sizeof(bool), unsafe_offsetof(physx_PxCookingParams_Pod, suppressTriangleMeshRemapTable));
        structGen.addField("bool buildTriangleAdjacencies", "buildTriangleAdjacencies", "bool",sizeof(bool), unsafe_offsetof(physx_PxCookingParams_Pod, buildTriangleAdjacencies));
        structGen.addField("bool buildGPUData", "buildGPUData", "bool",sizeof(bool), unsafe_offsetof(physx_PxCookingParams_Pod, buildGPUData));
        structGen.addField("physx_PxTolerancesScale_Pod scale", "scale", "PxTolerancesScale",sizeof(physx::PxTolerancesScale), unsafe_offsetof(physx_PxCookingParams_Pod, scale));
        structGen.addField("physx_PxMeshPreprocessingFlags_Pod meshPreprocessParams", "meshPreprocessParams", "PxMeshPreprocessingFlags",sizeof(physx::PxMeshPreprocessingFlags), unsafe_offsetof(physx_PxCookingParams_Pod, meshPreprocessParams));
        structGen.addField("float meshWeldTolerance", "meshWeldTolerance", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxCookingParams_Pod, meshWeldTolerance));
        structGen.addField("physx_PxMidphaseDesc_Pod midphaseDesc", "midphaseDesc", "PxMidphaseDesc",sizeof(physx::PxMidphaseDesc), unsafe_offsetof(physx_PxCookingParams_Pod, midphaseDesc));
        structGen.addField("uint32_t gaussMapLimit", "gaussMapLimit", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxCookingParams_Pod, gaussMapLimit));
        structGen.endStruct(sizeof(physx::PxCookingParams));
    }
};
physx_PxCookingParams_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxCooking_Pod {\n    void* vtable_;\n};\n");
struct physx_PxDefaultMemoryOutputStream_Pod: public physx::PxDefaultMemoryOutputStream {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxDefaultMemoryOutputStream_Pod", "PxDefaultMemoryOutputStream");
        structGen.endStruct(sizeof(physx::PxDefaultMemoryOutputStream));
    }
};
physx_PxDefaultMemoryOutputStream_Pod::dumpLayout(structGen);

struct physx_PxDefaultMemoryInputData_Pod: public physx::PxDefaultMemoryInputData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxDefaultMemoryInputData_Pod", "PxDefaultMemoryInputData");
        structGen.endStruct(sizeof(physx::PxDefaultMemoryInputData));
    }
};
physx_PxDefaultMemoryInputData_Pod::dumpLayout(structGen);

struct physx_PxDefaultFileOutputStream_Pod: public physx::PxDefaultFileOutputStream {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxDefaultFileOutputStream_Pod", "PxDefaultFileOutputStream");
        structGen.endStruct(sizeof(physx::PxDefaultFileOutputStream));
    }
};
physx_PxDefaultFileOutputStream_Pod::dumpLayout(structGen);

struct physx_PxDefaultFileInputData_Pod: public physx::PxDefaultFileInputData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxDefaultFileInputData_Pod", "PxDefaultFileInputData");
        structGen.endStruct(sizeof(physx::PxDefaultFileInputData));
    }
};
physx_PxDefaultFileInputData_Pod::dumpLayout(structGen);

struct physx_PxSpring_Pod: public physx::PxSpring {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSpring_Pod", "PxSpring");
        structGen.addField("float stiffness", "stiffness", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSpring_Pod, stiffness));
        structGen.addField("float damping", "damping", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxSpring_Pod, damping));
        structGen.endStruct(sizeof(physx::PxSpring));
    }
};
physx_PxSpring_Pod::dumpLayout(structGen);

struct physx_PxDistanceJoint_Pod: public physx::PxDistanceJoint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxDistanceJoint_Pod", "PxDistanceJoint");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxDistanceJoint_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxDistanceJoint_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxDistanceJoint_Pod, userData));
        structGen.endStruct(sizeof(physx::PxDistanceJoint));
    }
};
physx_PxDistanceJoint_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxDistanceJointFlags_Pod {\n    uint16_t mBits;\n};\n");
structGen.passThroughC("struct physx_PxDefaultAllocator_Pod {\n    void* vtable_;\n};\n");
struct physx_PxContactJoint_Pod: public physx::PxContactJoint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxContactJoint_Pod", "PxContactJoint");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxContactJoint_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxContactJoint_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxContactJoint_Pod, userData));
        structGen.endStruct(sizeof(physx::PxContactJoint));
    }
};
physx_PxContactJoint_Pod::dumpLayout(structGen);

struct physx_PxJacobianRow_Pod: public physx::PxJacobianRow {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxJacobianRow_Pod", "PxJacobianRow");
        structGen.addField("physx_PxVec3_Pod linear0", "linear0", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxJacobianRow_Pod, linear0));
        structGen.addField("physx_PxVec3_Pod linear1", "linear1", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxJacobianRow_Pod, linear1));
        structGen.addField("physx_PxVec3_Pod angular0", "angular0", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxJacobianRow_Pod, angular0));
        structGen.addField("physx_PxVec3_Pod angular1", "angular1", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxJacobianRow_Pod, angular1));
        structGen.endStruct(sizeof(physx::PxJacobianRow));
    }
};
physx_PxJacobianRow_Pod::dumpLayout(structGen);

struct physx_PxFixedJoint_Pod: public physx::PxFixedJoint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxFixedJoint_Pod", "PxFixedJoint");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxFixedJoint_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxFixedJoint_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxFixedJoint_Pod, userData));
        structGen.endStruct(sizeof(physx::PxFixedJoint));
    }
};
physx_PxFixedJoint_Pod::dumpLayout(structGen);

struct physx_PxJointLimitParameters_Pod: public physx::PxJointLimitParameters {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxJointLimitParameters_Pod", "PxJointLimitParameters");
        structGen.addField("float restitution", "restitution", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitParameters_Pod, restitution));
        structGen.addField("float bounceThreshold", "bounceThreshold", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitParameters_Pod, bounceThreshold));
        structGen.addField("float stiffness", "stiffness", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitParameters_Pod, stiffness));
        structGen.addField("float damping", "damping", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitParameters_Pod, damping));
        structGen.addField("float contactDistance", "contactDistance", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitParameters_Pod, contactDistance));
        structGen.endStruct(sizeof(physx::PxJointLimitParameters));
    }
};
physx_PxJointLimitParameters_Pod::dumpLayout(structGen);

struct physx_PxJointLinearLimit_Pod: public physx::PxJointLinearLimit {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxJointLinearLimit_Pod", "PxJointLinearLimit");
        structGen.addField("float restitution", "restitution", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimit_Pod, restitution));
        structGen.addField("float bounceThreshold", "bounceThreshold", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimit_Pod, bounceThreshold));
        structGen.addField("float stiffness", "stiffness", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimit_Pod, stiffness));
        structGen.addField("float damping", "damping", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimit_Pod, damping));
        structGen.addField("float contactDistance", "contactDistance", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimit_Pod, contactDistance));
        structGen.addField("float value", "value", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimit_Pod, value));
        structGen.endStruct(sizeof(physx::PxJointLinearLimit));
    }
};
physx_PxJointLinearLimit_Pod::dumpLayout(structGen);

struct physx_PxJointLinearLimitPair_Pod: public physx::PxJointLinearLimitPair {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxJointLinearLimitPair_Pod", "PxJointLinearLimitPair");
        structGen.addField("float restitution", "restitution", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, restitution));
        structGen.addField("float bounceThreshold", "bounceThreshold", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, bounceThreshold));
        structGen.addField("float stiffness", "stiffness", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, stiffness));
        structGen.addField("float damping", "damping", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, damping));
        structGen.addField("float contactDistance", "contactDistance", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, contactDistance));
        structGen.addField("float upper", "upper", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, upper));
        structGen.addField("float lower", "lower", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, lower));
        structGen.endStruct(sizeof(physx::PxJointLinearLimitPair));
    }
};
physx_PxJointLinearLimitPair_Pod::dumpLayout(structGen);

struct physx_PxJointAngularLimitPair_Pod: public physx::PxJointAngularLimitPair {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxJointAngularLimitPair_Pod", "PxJointAngularLimitPair");
        structGen.addField("float restitution", "restitution", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, restitution));
        structGen.addField("float bounceThreshold", "bounceThreshold", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, bounceThreshold));
        structGen.addField("float stiffness", "stiffness", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, stiffness));
        structGen.addField("float damping", "damping", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, damping));
        structGen.addField("float contactDistance", "contactDistance", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, contactDistance));
        structGen.addField("float upper", "upper", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, upper));
        structGen.addField("float lower", "lower", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, lower));
        structGen.endStruct(sizeof(physx::PxJointAngularLimitPair));
    }
};
physx_PxJointAngularLimitPair_Pod::dumpLayout(structGen);

struct physx_PxJointLimitCone_Pod: public physx::PxJointLimitCone {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxJointLimitCone_Pod", "PxJointLimitCone");
        structGen.addField("float restitution", "restitution", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitCone_Pod, restitution));
        structGen.addField("float bounceThreshold", "bounceThreshold", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitCone_Pod, bounceThreshold));
        structGen.addField("float stiffness", "stiffness", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitCone_Pod, stiffness));
        structGen.addField("float damping", "damping", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitCone_Pod, damping));
        structGen.addField("float contactDistance", "contactDistance", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitCone_Pod, contactDistance));
        structGen.addField("float yAngle", "yAngle", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitCone_Pod, yAngle));
        structGen.addField("float zAngle", "zAngle", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitCone_Pod, zAngle));
        structGen.endStruct(sizeof(physx::PxJointLimitCone));
    }
};
physx_PxJointLimitCone_Pod::dumpLayout(structGen);

struct physx_PxJointLimitPyramid_Pod: public physx::PxJointLimitPyramid {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxJointLimitPyramid_Pod", "PxJointLimitPyramid");
        structGen.addField("float restitution", "restitution", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, restitution));
        structGen.addField("float bounceThreshold", "bounceThreshold", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, bounceThreshold));
        structGen.addField("float stiffness", "stiffness", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, stiffness));
        structGen.addField("float damping", "damping", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, damping));
        structGen.addField("float contactDistance", "contactDistance", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, contactDistance));
        structGen.addField("float yAngleMin", "yAngleMin", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, yAngleMin));
        structGen.addField("float yAngleMax", "yAngleMax", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, yAngleMax));
        structGen.addField("float zAngleMin", "zAngleMin", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, zAngleMin));
        structGen.addField("float zAngleMax", "zAngleMax", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, zAngleMax));
        structGen.endStruct(sizeof(physx::PxJointLimitPyramid));
    }
};
physx_PxJointLimitPyramid_Pod::dumpLayout(structGen);

struct physx_PxPrismaticJoint_Pod: public physx::PxPrismaticJoint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxPrismaticJoint_Pod", "PxPrismaticJoint");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxPrismaticJoint_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxPrismaticJoint_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxPrismaticJoint_Pod, userData));
        structGen.endStruct(sizeof(physx::PxPrismaticJoint));
    }
};
physx_PxPrismaticJoint_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxPrismaticJointFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxRevoluteJoint_Pod: public physx::PxRevoluteJoint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxRevoluteJoint_Pod", "PxRevoluteJoint");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxRevoluteJoint_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxRevoluteJoint_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxRevoluteJoint_Pod, userData));
        structGen.endStruct(sizeof(physx::PxRevoluteJoint));
    }
};
physx_PxRevoluteJoint_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxRevoluteJointFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxSphericalJoint_Pod: public physx::PxSphericalJoint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSphericalJoint_Pod", "PxSphericalJoint");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxSphericalJoint_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxSphericalJoint_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxSphericalJoint_Pod, userData));
        structGen.endStruct(sizeof(physx::PxSphericalJoint));
    }
};
physx_PxSphericalJoint_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxSphericalJointFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxD6Joint_Pod: public physx::PxD6Joint {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxD6Joint_Pod", "PxD6Joint");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxD6Joint_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxD6Joint_Pod, mBaseFlags));
        structGen.addField("void* userData", "userData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxD6Joint_Pod, userData));
        structGen.endStruct(sizeof(physx::PxD6Joint));
    }
};
physx_PxD6Joint_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxD6JointDriveFlags_Pod {\n    uint32_t mBits;\n};\n");
struct physx_PxD6JointDrive_Pod: public physx::PxD6JointDrive {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxD6JointDrive_Pod", "PxD6JointDrive");
        structGen.addField("float stiffness", "stiffness", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxD6JointDrive_Pod, stiffness));
        structGen.addField("float damping", "damping", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxD6JointDrive_Pod, damping));
        structGen.addField("float forceLimit", "forceLimit", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxD6JointDrive_Pod, forceLimit));
        structGen.addField("physx_PxD6JointDriveFlags_Pod flags", "flags", "PxD6JointDriveFlags",sizeof(physx::PxD6JointDriveFlags), unsafe_offsetof(physx_PxD6JointDrive_Pod, flags));
        structGen.endStruct(sizeof(physx::PxD6JointDrive));
    }
};
physx_PxD6JointDrive_Pod::dumpLayout(structGen);

struct physx_PxGroupsMask_Pod: public physx::PxGroupsMask {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxGroupsMask_Pod", "PxGroupsMask");
        structGen.addField("uint16_t bits0", "bits0", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxGroupsMask_Pod, bits0));
        structGen.addField("uint16_t bits1", "bits1", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxGroupsMask_Pod, bits1));
        structGen.addField("uint16_t bits2", "bits2", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxGroupsMask_Pod, bits2));
        structGen.addField("uint16_t bits3", "bits3", "u16",sizeof(physx::PxU16), unsafe_offsetof(physx_PxGroupsMask_Pod, bits3));
        structGen.endStruct(sizeof(physx::PxGroupsMask));
    }
};
physx_PxGroupsMask_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxDefaultErrorCallback_Pod {\n    void* vtable_;\n};\n");
struct physx_PxMassProperties_Pod: public physx::PxMassProperties {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxMassProperties_Pod", "PxMassProperties");
        structGen.addField("physx_PxMat33_Pod inertiaTensor", "inertiaTensor", "PxMat33",sizeof(physx::PxMat33), unsafe_offsetof(physx_PxMassProperties_Pod, inertiaTensor));
        structGen.addField("physx_PxVec3_Pod centerOfMass", "centerOfMass", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxMassProperties_Pod, centerOfMass));
        structGen.addField("float mass", "mass", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxMassProperties_Pod, mass));
        structGen.endStruct(sizeof(physx::PxMassProperties));
    }
};
physx_PxMassProperties_Pod::dumpLayout(structGen);

struct physx_PxMeshOverlapUtil_Pod: public physx::PxMeshOverlapUtil {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxMeshOverlapUtil_Pod", "PxMeshOverlapUtil");
        structGen.endStruct(sizeof(physx::PxMeshOverlapUtil));
    }
};
physx_PxMeshOverlapUtil_Pod::dumpLayout(structGen);

struct physx_PxSerialization_PxXmlMiscParameter_Pod: public physx::PxSerialization::PxXmlMiscParameter {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSerialization_PxXmlMiscParameter_Pod", "PxSerialization_PxXmlMiscParameter");
        structGen.addField("physx_PxVec3_Pod upVector", "upVector", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSerialization_PxXmlMiscParameter_Pod, upVector));
        structGen.addField("physx_PxTolerancesScale_Pod scale", "scale", "PxTolerancesScale",sizeof(physx::PxTolerancesScale), unsafe_offsetof(physx_PxSerialization_PxXmlMiscParameter_Pod, scale));
        structGen.endStruct(sizeof(physx::PxSerialization::PxXmlMiscParameter));
    }
};
physx_PxSerialization_PxXmlMiscParameter_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxBinaryConverter_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxDefaultCpuDispatcher_Pod {\n    void* vtable_;\n};\n");
struct physx_PxSceneQueryHit_Pod: public physx::PxSceneQueryHit {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSceneQueryHit_Pod", "PxSceneQueryHit");
        structGen.addField("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxSceneQueryHit_Pod, actor));
        structGen.addField("physx_PxShape_Pod* shape", "shape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxSceneQueryHit_Pod, shape));
        structGen.addField("uint32_t faceIndex", "faceIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneQueryHit_Pod, faceIndex));
        structGen.endStruct(sizeof(physx::PxSceneQueryHit));
    }
};
physx_PxSceneQueryHit_Pod::dumpLayout(structGen);

struct physx_PxSceneQueryFilterData_Pod: public physx::PxSceneQueryFilterData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSceneQueryFilterData_Pod", "PxSceneQueryFilterData");
        structGen.addField("physx_PxFilterData_Pod data", "data", "PxFilterData",sizeof(physx::PxFilterData), unsafe_offsetof(physx_PxSceneQueryFilterData_Pod, data));
        structGen.addField("physx_PxQueryFlags_Pod flags", "flags", "PxQueryFlags",sizeof(physx::PxQueryFlags), unsafe_offsetof(physx_PxSceneQueryFilterData_Pod, flags));
        structGen.endStruct(sizeof(physx::PxSceneQueryFilterData));
    }
};
physx_PxSceneQueryFilterData_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxSceneQueryFilterCallback_Pod {\n    void* vtable_;\n};\n");
struct physx_PxSceneQueryCache_Pod: public physx::PxSceneQueryCache {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxSceneQueryCache_Pod", "PxSceneQueryCache");
        structGen.addField("physx_PxShape_Pod* shape", "shape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxSceneQueryCache_Pod, shape));
        structGen.addField("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor",sizeof(physx::PxRigidActor *), unsafe_offsetof(physx_PxSceneQueryCache_Pod, actor));
        structGen.addField("uint32_t faceIndex", "faceIndex", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxSceneQueryCache_Pod, faceIndex));
        structGen.endStruct(sizeof(physx::PxSceneQueryCache));
    }
};
physx_PxSceneQueryCache_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxSceneQueryFlags_Pod {\n    uint16_t mBits;\n};\n");
struct physx_PxRepXObject_Pod: public physx::PxRepXObject {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxRepXObject_Pod", "PxRepXObject");
        structGen.addField("char* typeName", "typeName", "*const i8",sizeof(const char *), unsafe_offsetof(physx_PxRepXObject_Pod, typeName));
        structGen.addField("void* serializable", "serializable", "*const std::ffi::c_void",sizeof(const void *), unsafe_offsetof(physx_PxRepXObject_Pod, serializable));
        structGen.addField("uint64_t id", "id", "usize",sizeof(physx::PxSerialObjectId), unsafe_offsetof(physx_PxRepXObject_Pod, id));
        structGen.endStruct(sizeof(physx::PxRepXObject));
    }
};
physx_PxRepXObject_Pod::dumpLayout(structGen);

struct physx_PxRepXInstantiationArgs_Pod: public physx::PxRepXInstantiationArgs {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxRepXInstantiationArgs_Pod", "PxRepXInstantiationArgs");
        structGen.addField("physx_PxCooking_Pod* cooker", "cooker", "*mut PxCooking",sizeof(physx::PxCooking *), unsafe_offsetof(physx_PxRepXInstantiationArgs_Pod, cooker));
        structGen.addField("physx_PxStringTable_Pod* stringTable", "stringTable", "*mut PxStringTable",sizeof(physx::PxStringTable *), unsafe_offsetof(physx_PxRepXInstantiationArgs_Pod, stringTable));
        structGen.endStruct(sizeof(physx::PxRepXInstantiationArgs));
    }
};
physx_PxRepXInstantiationArgs_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_XmlWriter_Pod;\n");
structGen.passThroughC("struct physx_MemoryBuffer_Pod;\n");
structGen.passThroughC("struct physx_XmlReader_Pod;\n");
structGen.passThroughC("struct physx_XmlMemoryAllocator_Pod;\n");
struct physx_PxVehicleChassisData_Pod: public physx::PxVehicleChassisData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleChassisData_Pod", "PxVehicleChassisData");
        structGen.addField("physx_PxVec3_Pod mMOI", "mMOI", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxVehicleChassisData_Pod, mMOI));
        structGen.addField("float mMass", "mMass", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleChassisData_Pod, mMass));
        structGen.addField("physx_PxVec3_Pod mCMOffset", "mCMOffset", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxVehicleChassisData_Pod, mCMOffset));
        structGen.endStruct(sizeof(physx::PxVehicleChassisData));
    }
};
physx_PxVehicleChassisData_Pod::dumpLayout(structGen);

structGen.passThroughC("struct PxFixedSizeLookupTable_eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES__Pod {\n    float mDataPairs[16];\n    uint32_t mNbDataPairs;\n    uint32_t mPad[3];\n};\n");
struct physx_PxVehicleEngineData_Pod: public physx::PxVehicleEngineData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleEngineData_Pod", "PxVehicleEngineData");
        structGen.addField("PxFixedSizeLookupTable_eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES__Pod mTorqueCurve", "mTorqueCurve", "PxFixedSizeLookupTable_eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES_",sizeof(PxFixedSizeLookupTable<eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES>), unsafe_offsetof(physx_PxVehicleEngineData_Pod, mTorqueCurve));
        structGen.addField("float mMOI", "mMOI", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleEngineData_Pod, mMOI));
        structGen.addField("float mPeakTorque", "mPeakTorque", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleEngineData_Pod, mPeakTorque));
        structGen.addField("float mMaxOmega", "mMaxOmega", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleEngineData_Pod, mMaxOmega));
        structGen.addField("float mDampingRateFullThrottle", "mDampingRateFullThrottle", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleEngineData_Pod, mDampingRateFullThrottle));
        structGen.addField("float mDampingRateZeroThrottleClutchEngaged", "mDampingRateZeroThrottleClutchEngaged", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleEngineData_Pod, mDampingRateZeroThrottleClutchEngaged));
        structGen.addField("float mDampingRateZeroThrottleClutchDisengaged", "mDampingRateZeroThrottleClutchDisengaged", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleEngineData_Pod, mDampingRateZeroThrottleClutchDisengaged));
        structGen.endStruct(sizeof(physx::PxVehicleEngineData));
    }
};
physx_PxVehicleEngineData_Pod::dumpLayout(structGen);

struct physx_PxVehicleGearsData_Pod: public physx::PxVehicleGearsData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleGearsData_Pod", "PxVehicleGearsData");
        structGen.addField("float mRatios[32]", "mRatios", "[f32; 32]",sizeof(physx::PxReal[32]), unsafe_offsetof(physx_PxVehicleGearsData_Pod, mRatios));
        structGen.addField("float mFinalRatio", "mFinalRatio", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleGearsData_Pod, mFinalRatio));
        structGen.addField("uint32_t mNbRatios", "mNbRatios", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxVehicleGearsData_Pod, mNbRatios));
        structGen.addField("float mSwitchTime", "mSwitchTime", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleGearsData_Pod, mSwitchTime));
        structGen.endStruct(sizeof(physx::PxVehicleGearsData));
    }
};
physx_PxVehicleGearsData_Pod::dumpLayout(structGen);

struct physx_PxVehicleAutoBoxData_Pod: public physx::PxVehicleAutoBoxData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleAutoBoxData_Pod", "PxVehicleAutoBoxData");
        structGen.addField("float mUpRatios[32]", "mUpRatios", "[f32; 32]",sizeof(physx::PxReal[32]), unsafe_offsetof(physx_PxVehicleAutoBoxData_Pod, mUpRatios));
        structGen.addField("float mDownRatios[32]", "mDownRatios", "[f32; 32]",sizeof(physx::PxReal[32]), unsafe_offsetof(physx_PxVehicleAutoBoxData_Pod, mDownRatios));
        structGen.endStruct(sizeof(physx::PxVehicleAutoBoxData));
    }
};
physx_PxVehicleAutoBoxData_Pod::dumpLayout(structGen);

struct physx_PxVehicleDifferential4WData_Pod: public physx::PxVehicleDifferential4WData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDifferential4WData_Pod", "PxVehicleDifferential4WData");
        structGen.addField("float mFrontRearSplit", "mFrontRearSplit", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleDifferential4WData_Pod, mFrontRearSplit));
        structGen.addField("float mFrontLeftRightSplit", "mFrontLeftRightSplit", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleDifferential4WData_Pod, mFrontLeftRightSplit));
        structGen.addField("float mRearLeftRightSplit", "mRearLeftRightSplit", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleDifferential4WData_Pod, mRearLeftRightSplit));
        structGen.addField("float mCentreBias", "mCentreBias", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleDifferential4WData_Pod, mCentreBias));
        structGen.addField("float mFrontBias", "mFrontBias", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleDifferential4WData_Pod, mFrontBias));
        structGen.addField("float mRearBias", "mRearBias", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleDifferential4WData_Pod, mRearBias));
        structGen.addField("unsigned int mType", "mType", "u32",sizeof(PxVehicleDifferential4WData::Enum), unsafe_offsetof(physx_PxVehicleDifferential4WData_Pod, mType));
        structGen.endStruct(sizeof(physx::PxVehicleDifferential4WData));
    }
};
physx_PxVehicleDifferential4WData_Pod::dumpLayout(structGen);

struct physx_PxVehicleDifferentialNWData_Pod: public physx::PxVehicleDifferentialNWData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDifferentialNWData_Pod", "PxVehicleDifferentialNWData");
        structGen.endStruct(sizeof(physx::PxVehicleDifferentialNWData));
    }
};
physx_PxVehicleDifferentialNWData_Pod::dumpLayout(structGen);

struct physx_PxVehicleAckermannGeometryData_Pod: public physx::PxVehicleAckermannGeometryData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleAckermannGeometryData_Pod", "PxVehicleAckermannGeometryData");
        structGen.addField("float mAccuracy", "mAccuracy", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleAckermannGeometryData_Pod, mAccuracy));
        structGen.addField("float mFrontWidth", "mFrontWidth", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleAckermannGeometryData_Pod, mFrontWidth));
        structGen.addField("float mRearWidth", "mRearWidth", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleAckermannGeometryData_Pod, mRearWidth));
        structGen.addField("float mAxleSeparation", "mAxleSeparation", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleAckermannGeometryData_Pod, mAxleSeparation));
        structGen.endStruct(sizeof(physx::PxVehicleAckermannGeometryData));
    }
};
physx_PxVehicleAckermannGeometryData_Pod::dumpLayout(structGen);

struct physx_PxVehicleClutchData_Pod: public physx::PxVehicleClutchData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleClutchData_Pod", "PxVehicleClutchData");
        structGen.addField("float mStrength", "mStrength", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleClutchData_Pod, mStrength));
        structGen.addField("unsigned int mAccuracyMode", "mAccuracyMode", "u32",sizeof(PxVehicleClutchAccuracyMode::Enum), unsafe_offsetof(physx_PxVehicleClutchData_Pod, mAccuracyMode));
        structGen.addField("uint32_t mEstimateIterations", "mEstimateIterations", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxVehicleClutchData_Pod, mEstimateIterations));
        structGen.endStruct(sizeof(physx::PxVehicleClutchData));
    }
};
physx_PxVehicleClutchData_Pod::dumpLayout(structGen);

struct physx_PxVehicleTireLoadFilterData_Pod: public physx::PxVehicleTireLoadFilterData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleTireLoadFilterData_Pod", "PxVehicleTireLoadFilterData");
        structGen.addField("float mMinNormalisedLoad", "mMinNormalisedLoad", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleTireLoadFilterData_Pod, mMinNormalisedLoad));
        structGen.addField("float mMinFilteredNormalisedLoad", "mMinFilteredNormalisedLoad", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleTireLoadFilterData_Pod, mMinFilteredNormalisedLoad));
        structGen.addField("float mMaxNormalisedLoad", "mMaxNormalisedLoad", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleTireLoadFilterData_Pod, mMaxNormalisedLoad));
        structGen.addField("float mMaxFilteredNormalisedLoad", "mMaxFilteredNormalisedLoad", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleTireLoadFilterData_Pod, mMaxFilteredNormalisedLoad));
        structGen.endStruct(sizeof(physx::PxVehicleTireLoadFilterData));
    }
};
physx_PxVehicleTireLoadFilterData_Pod::dumpLayout(structGen);

struct physx_PxVehicleWheelData_Pod: public physx::PxVehicleWheelData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleWheelData_Pod", "PxVehicleWheelData");
        structGen.addField("float mRadius", "mRadius", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleWheelData_Pod, mRadius));
        structGen.addField("float mWidth", "mWidth", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleWheelData_Pod, mWidth));
        structGen.addField("float mMass", "mMass", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleWheelData_Pod, mMass));
        structGen.addField("float mMOI", "mMOI", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleWheelData_Pod, mMOI));
        structGen.addField("float mDampingRate", "mDampingRate", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleWheelData_Pod, mDampingRate));
        structGen.addField("float mMaxBrakeTorque", "mMaxBrakeTorque", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleWheelData_Pod, mMaxBrakeTorque));
        structGen.addField("float mMaxHandBrakeTorque", "mMaxHandBrakeTorque", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleWheelData_Pod, mMaxHandBrakeTorque));
        structGen.addField("float mMaxSteer", "mMaxSteer", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleWheelData_Pod, mMaxSteer));
        structGen.addField("float mToeAngle", "mToeAngle", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleWheelData_Pod, mToeAngle));
        structGen.endStruct(sizeof(physx::PxVehicleWheelData));
    }
};
physx_PxVehicleWheelData_Pod::dumpLayout(structGen);

struct physx_PxVehicleSuspensionData_Pod: public physx::PxVehicleSuspensionData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleSuspensionData_Pod", "PxVehicleSuspensionData");
        structGen.addField("float mSpringStrength", "mSpringStrength", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleSuspensionData_Pod, mSpringStrength));
        structGen.addField("float mSpringDamperRate", "mSpringDamperRate", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleSuspensionData_Pod, mSpringDamperRate));
        structGen.addField("float mMaxCompression", "mMaxCompression", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleSuspensionData_Pod, mMaxCompression));
        structGen.addField("float mMaxDroop", "mMaxDroop", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleSuspensionData_Pod, mMaxDroop));
        structGen.addField("float mSprungMass", "mSprungMass", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleSuspensionData_Pod, mSprungMass));
        structGen.addField("float mCamberAtRest", "mCamberAtRest", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleSuspensionData_Pod, mCamberAtRest));
        structGen.addField("float mCamberAtMaxCompression", "mCamberAtMaxCompression", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleSuspensionData_Pod, mCamberAtMaxCompression));
        structGen.addField("float mCamberAtMaxDroop", "mCamberAtMaxDroop", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleSuspensionData_Pod, mCamberAtMaxDroop));
        structGen.endStruct(sizeof(physx::PxVehicleSuspensionData));
    }
};
physx_PxVehicleSuspensionData_Pod::dumpLayout(structGen);

struct physx_PxVehicleAntiRollBarData_Pod: public physx::PxVehicleAntiRollBarData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleAntiRollBarData_Pod", "PxVehicleAntiRollBarData");
        structGen.addField("uint32_t mWheel0", "mWheel0", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxVehicleAntiRollBarData_Pod, mWheel0));
        structGen.addField("uint32_t mWheel1", "mWheel1", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxVehicleAntiRollBarData_Pod, mWheel1));
        structGen.addField("float mStiffness", "mStiffness", "f32",sizeof(physx::PxF32), unsafe_offsetof(physx_PxVehicleAntiRollBarData_Pod, mStiffness));
        structGen.endStruct(sizeof(physx::PxVehicleAntiRollBarData));
    }
};
physx_PxVehicleAntiRollBarData_Pod::dumpLayout(structGen);

struct physx_PxVehicleTireData_Pod: public physx::PxVehicleTireData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleTireData_Pod", "PxVehicleTireData");
        structGen.addField("float mLatStiffX", "mLatStiffX", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleTireData_Pod, mLatStiffX));
        structGen.addField("float mLatStiffY", "mLatStiffY", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleTireData_Pod, mLatStiffY));
        structGen.addField("float mLongitudinalStiffnessPerUnitGravity", "mLongitudinalStiffnessPerUnitGravity", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleTireData_Pod, mLongitudinalStiffnessPerUnitGravity));
        structGen.addField("float mCamberStiffnessPerUnitGravity", "mCamberStiffnessPerUnitGravity", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleTireData_Pod, mCamberStiffnessPerUnitGravity));
        structGen.addField("float mFrictionVsSlipGraph[3][2]", "mFrictionVsSlipGraph", "[[f32; 2]; 3]",sizeof(physx::PxReal[3][2]), unsafe_offsetof(physx_PxVehicleTireData_Pod, mFrictionVsSlipGraph));
        structGen.addField("uint32_t mType", "mType", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxVehicleTireData_Pod, mType));
        structGen.endStruct(sizeof(physx::PxVehicleTireData));
    }
};
physx_PxVehicleTireData_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxVehicleWheels4SimData_Pod;\n");
struct physx_PxVehicleWheelsSimData_Pod: public physx::PxVehicleWheelsSimData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleWheelsSimData_Pod", "PxVehicleWheelsSimData");
        structGen.endStruct(sizeof(physx::PxVehicleWheelsSimData));
    }
};
physx_PxVehicleWheelsSimData_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxVehicleWheelsSimFlags_Pod {\n    uint32_t mBits;\n};\n");
structGen.passThroughC("struct physx_PxVehicleWheels4DynData_Pod;\n");
structGen.passThroughC("struct physx_PxVehicleTireForceCalculator_Pod;\n");
struct physx_PxVehicleWheelsDynData_Pod: public physx::PxVehicleWheelsDynData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleWheelsDynData_Pod", "PxVehicleWheelsDynData");
        structGen.endStruct(sizeof(physx::PxVehicleWheelsDynData));
    }
};
physx_PxVehicleWheelsDynData_Pod::dumpLayout(structGen);

struct physx_PxVehicleWheels_Pod: public physx::PxVehicleWheels {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleWheels_Pod", "PxVehicleWheels");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxVehicleWheels_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxVehicleWheels_Pod, mBaseFlags));
        structGen.addField("physx_PxVehicleWheelsSimData_Pod mWheelsSimData", "mWheelsSimData", "PxVehicleWheelsSimData",sizeof(physx::PxVehicleWheelsSimData), unsafe_offsetof(physx_PxVehicleWheels_Pod, mWheelsSimData));
        structGen.addField("physx_PxVehicleWheelsDynData_Pod mWheelsDynData", "mWheelsDynData", "PxVehicleWheelsDynData",sizeof(physx::PxVehicleWheelsDynData), unsafe_offsetof(physx_PxVehicleWheels_Pod, mWheelsDynData));
        structGen.addField("physx_PxRigidDynamic_Pod* mActor", "mActor", "*mut PxRigidDynamic",sizeof(physx::PxRigidDynamic *), unsafe_offsetof(physx_PxVehicleWheels_Pod, mActor));
        structGen.addField("unsigned char mType", "mType", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxVehicleWheels_Pod, mType));
        structGen.addField("unsigned char mPad0[14]", "mPad0", "[u8; 14]",sizeof(physx::PxU8[14]), unsafe_offsetof(physx_PxVehicleWheels_Pod, mPad0));
        structGen.endStruct(sizeof(physx::PxVehicleWheels));
    }
};
physx_PxVehicleWheels_Pod::dumpLayout(structGen);

struct physx_PxVehicleDriveSimData_Pod: public physx::PxVehicleDriveSimData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDriveSimData_Pod", "PxVehicleDriveSimData");
        structGen.addField("physx_PxVehicleEngineData_Pod mEngine", "mEngine", "PxVehicleEngineData",sizeof(physx::PxVehicleEngineData), unsafe_offsetof(physx_PxVehicleDriveSimData_Pod, mEngine));
        structGen.addField("physx_PxVehicleGearsData_Pod mGears", "mGears", "PxVehicleGearsData",sizeof(physx::PxVehicleGearsData), unsafe_offsetof(physx_PxVehicleDriveSimData_Pod, mGears));
        structGen.addField("physx_PxVehicleClutchData_Pod mClutch", "mClutch", "PxVehicleClutchData",sizeof(physx::PxVehicleClutchData), unsafe_offsetof(physx_PxVehicleDriveSimData_Pod, mClutch));
        structGen.addField("physx_PxVehicleAutoBoxData_Pod mAutoBox", "mAutoBox", "PxVehicleAutoBoxData",sizeof(physx::PxVehicleAutoBoxData), unsafe_offsetof(physx_PxVehicleDriveSimData_Pod, mAutoBox));
        structGen.endStruct(sizeof(physx::PxVehicleDriveSimData));
    }
};
physx_PxVehicleDriveSimData_Pod::dumpLayout(structGen);

struct physx_PxVehicleDriveDynData_Pod: public physx::PxVehicleDriveDynData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDriveDynData_Pod", "PxVehicleDriveDynData");
        structGen.addField("float mControlAnalogVals[16]", "mControlAnalogVals", "[f32; 16]",sizeof(physx::PxReal[16]), unsafe_offsetof(physx_PxVehicleDriveDynData_Pod, mControlAnalogVals));
        structGen.addField("bool mUseAutoGears", "mUseAutoGears", "bool",sizeof(bool), unsafe_offsetof(physx_PxVehicleDriveDynData_Pod, mUseAutoGears));
        structGen.addField("bool mGearUpPressed", "mGearUpPressed", "bool",sizeof(bool), unsafe_offsetof(physx_PxVehicleDriveDynData_Pod, mGearUpPressed));
        structGen.addField("bool mGearDownPressed", "mGearDownPressed", "bool",sizeof(bool), unsafe_offsetof(physx_PxVehicleDriveDynData_Pod, mGearDownPressed));
        structGen.addField("uint32_t mCurrentGear", "mCurrentGear", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxVehicleDriveDynData_Pod, mCurrentGear));
        structGen.addField("uint32_t mTargetGear", "mTargetGear", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxVehicleDriveDynData_Pod, mTargetGear));
        structGen.addField("float mEnginespeed", "mEnginespeed", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleDriveDynData_Pod, mEnginespeed));
        structGen.addField("float mGearSwitchTime", "mGearSwitchTime", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleDriveDynData_Pod, mGearSwitchTime));
        structGen.addField("float mAutoBoxSwitchTime", "mAutoBoxSwitchTime", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleDriveDynData_Pod, mAutoBoxSwitchTime));
        structGen.endStruct(sizeof(physx::PxVehicleDriveDynData));
    }
};
physx_PxVehicleDriveDynData_Pod::dumpLayout(structGen);

struct physx_PxVehicleDrive_Pod: public physx::PxVehicleDrive {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDrive_Pod", "PxVehicleDrive");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxVehicleDrive_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxVehicleDrive_Pod, mBaseFlags));
        structGen.addField("physx_PxVehicleWheelsSimData_Pod mWheelsSimData", "mWheelsSimData", "PxVehicleWheelsSimData",sizeof(physx::PxVehicleWheelsSimData), unsafe_offsetof(physx_PxVehicleDrive_Pod, mWheelsSimData));
        structGen.addField("physx_PxVehicleWheelsDynData_Pod mWheelsDynData", "mWheelsDynData", "PxVehicleWheelsDynData",sizeof(physx::PxVehicleWheelsDynData), unsafe_offsetof(physx_PxVehicleDrive_Pod, mWheelsDynData));
        structGen.addField("physx_PxRigidDynamic_Pod* mActor", "mActor", "*mut PxRigidDynamic",sizeof(physx::PxRigidDynamic *), unsafe_offsetof(physx_PxVehicleDrive_Pod, mActor));
        structGen.addField("unsigned char mType", "mType", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxVehicleDrive_Pod, mType));
        structGen.addField("unsigned char mPad0[14]", "mPad0", "[u8; 14]",sizeof(physx::PxU8[14]), unsafe_offsetof(physx_PxVehicleDrive_Pod, mPad0));
        structGen.addField("physx_PxVehicleDriveDynData_Pod mDriveDynData", "mDriveDynData", "PxVehicleDriveDynData",sizeof(physx::PxVehicleDriveDynData), unsafe_offsetof(physx_PxVehicleDrive_Pod, mDriveDynData));
        structGen.endStruct(sizeof(physx::PxVehicleDrive));
    }
};
physx_PxVehicleDrive_Pod::dumpLayout(structGen);

struct physx_PxVehicleDriveSimData4W_Pod: public physx::PxVehicleDriveSimData4W {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDriveSimData4W_Pod", "PxVehicleDriveSimData4W");
        structGen.addField("physx_PxVehicleEngineData_Pod mEngine", "mEngine", "PxVehicleEngineData",sizeof(physx::PxVehicleEngineData), unsafe_offsetof(physx_PxVehicleDriveSimData4W_Pod, mEngine));
        structGen.addField("physx_PxVehicleGearsData_Pod mGears", "mGears", "PxVehicleGearsData",sizeof(physx::PxVehicleGearsData), unsafe_offsetof(physx_PxVehicleDriveSimData4W_Pod, mGears));
        structGen.addField("physx_PxVehicleClutchData_Pod mClutch", "mClutch", "PxVehicleClutchData",sizeof(physx::PxVehicleClutchData), unsafe_offsetof(physx_PxVehicleDriveSimData4W_Pod, mClutch));
        structGen.addField("physx_PxVehicleAutoBoxData_Pod mAutoBox", "mAutoBox", "PxVehicleAutoBoxData",sizeof(physx::PxVehicleAutoBoxData), unsafe_offsetof(physx_PxVehicleDriveSimData4W_Pod, mAutoBox));
        structGen.endStruct(sizeof(physx::PxVehicleDriveSimData4W));
    }
};
physx_PxVehicleDriveSimData4W_Pod::dumpLayout(structGen);

struct physx_PxVehicleDrive4W_Pod: public physx::PxVehicleDrive4W {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDrive4W_Pod", "PxVehicleDrive4W");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxVehicleDrive4W_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxVehicleDrive4W_Pod, mBaseFlags));
        structGen.addField("physx_PxVehicleWheelsSimData_Pod mWheelsSimData", "mWheelsSimData", "PxVehicleWheelsSimData",sizeof(physx::PxVehicleWheelsSimData), unsafe_offsetof(physx_PxVehicleDrive4W_Pod, mWheelsSimData));
        structGen.addField("physx_PxVehicleWheelsDynData_Pod mWheelsDynData", "mWheelsDynData", "PxVehicleWheelsDynData",sizeof(physx::PxVehicleWheelsDynData), unsafe_offsetof(physx_PxVehicleDrive4W_Pod, mWheelsDynData));
        structGen.addField("physx_PxRigidDynamic_Pod* mActor", "mActor", "*mut PxRigidDynamic",sizeof(physx::PxRigidDynamic *), unsafe_offsetof(physx_PxVehicleDrive4W_Pod, mActor));
        structGen.addField("unsigned char mType", "mType", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxVehicleDrive4W_Pod, mType));
        structGen.addField("unsigned char mPad0[14]", "mPad0", "[u8; 14]",sizeof(physx::PxU8[14]), unsafe_offsetof(physx_PxVehicleDrive4W_Pod, mPad0));
        structGen.addField("physx_PxVehicleDriveDynData_Pod mDriveDynData", "mDriveDynData", "PxVehicleDriveDynData",sizeof(physx::PxVehicleDriveDynData), unsafe_offsetof(physx_PxVehicleDrive4W_Pod, mDriveDynData));
        structGen.addField("physx_PxVehicleDriveSimData4W_Pod mDriveSimData", "mDriveSimData", "PxVehicleDriveSimData4W",sizeof(physx::PxVehicleDriveSimData4W), unsafe_offsetof(physx_PxVehicleDrive4W_Pod, mDriveSimData));
        structGen.endStruct(sizeof(physx::PxVehicleDrive4W));
    }
};
physx_PxVehicleDrive4W_Pod::dumpLayout(structGen);

struct physx_PxVehicleDriveTank_Pod: public physx::PxVehicleDriveTank {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDriveTank_Pod", "PxVehicleDriveTank");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxVehicleDriveTank_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxVehicleDriveTank_Pod, mBaseFlags));
        structGen.addField("physx_PxVehicleWheelsSimData_Pod mWheelsSimData", "mWheelsSimData", "PxVehicleWheelsSimData",sizeof(physx::PxVehicleWheelsSimData), unsafe_offsetof(physx_PxVehicleDriveTank_Pod, mWheelsSimData));
        structGen.addField("physx_PxVehicleWheelsDynData_Pod mWheelsDynData", "mWheelsDynData", "PxVehicleWheelsDynData",sizeof(physx::PxVehicleWheelsDynData), unsafe_offsetof(physx_PxVehicleDriveTank_Pod, mWheelsDynData));
        structGen.addField("physx_PxRigidDynamic_Pod* mActor", "mActor", "*mut PxRigidDynamic",sizeof(physx::PxRigidDynamic *), unsafe_offsetof(physx_PxVehicleDriveTank_Pod, mActor));
        structGen.addField("unsigned char mType", "mType", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxVehicleDriveTank_Pod, mType));
        structGen.addField("unsigned char mPad0[14]", "mPad0", "[u8; 14]",sizeof(physx::PxU8[14]), unsafe_offsetof(physx_PxVehicleDriveTank_Pod, mPad0));
        structGen.addField("physx_PxVehicleDriveDynData_Pod mDriveDynData", "mDriveDynData", "PxVehicleDriveDynData",sizeof(physx::PxVehicleDriveDynData), unsafe_offsetof(physx_PxVehicleDriveTank_Pod, mDriveDynData));
        structGen.addField("physx_PxVehicleDriveSimData_Pod mDriveSimData", "mDriveSimData", "PxVehicleDriveSimData",sizeof(physx::PxVehicleDriveSimData), unsafe_offsetof(physx_PxVehicleDriveTank_Pod, mDriveSimData));
        structGen.endStruct(sizeof(physx::PxVehicleDriveTank));
    }
};
physx_PxVehicleDriveTank_Pod::dumpLayout(structGen);

struct physx_PxVehicleDrivableSurfaceType_Pod: public physx::PxVehicleDrivableSurfaceType {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDrivableSurfaceType_Pod", "PxVehicleDrivableSurfaceType");
        structGen.addField("uint32_t mType", "mType", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxVehicleDrivableSurfaceType_Pod, mType));
        structGen.endStruct(sizeof(physx::PxVehicleDrivableSurfaceType));
    }
};
physx_PxVehicleDrivableSurfaceType_Pod::dumpLayout(structGen);

struct physx_PxVehicleDrivableSurfaceToTireFrictionPairs_Pod: public physx::PxVehicleDrivableSurfaceToTireFrictionPairs {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDrivableSurfaceToTireFrictionPairs_Pod", "PxVehicleDrivableSurfaceToTireFrictionPairs");
        structGen.endStruct(sizeof(physx::PxVehicleDrivableSurfaceToTireFrictionPairs));
    }
};
physx_PxVehicleDrivableSurfaceToTireFrictionPairs_Pod::dumpLayout(structGen);

struct physx_PxWheelQueryResult_Pod: public physx::PxWheelQueryResult {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxWheelQueryResult_Pod", "PxWheelQueryResult");
        structGen.addField("physx_PxVec3_Pod suspLineStart", "suspLineStart", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxWheelQueryResult_Pod, suspLineStart));
        structGen.addField("physx_PxVec3_Pod suspLineDir", "suspLineDir", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxWheelQueryResult_Pod, suspLineDir));
        structGen.addField("float suspLineLength", "suspLineLength", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxWheelQueryResult_Pod, suspLineLength));
        structGen.addField("bool isInAir", "isInAir", "bool",sizeof(bool), unsafe_offsetof(physx_PxWheelQueryResult_Pod, isInAir));
        structGen.addField("physx_PxActor_Pod* tireContactActor", "tireContactActor", "*mut PxActor",sizeof(physx::PxActor *), unsafe_offsetof(physx_PxWheelQueryResult_Pod, tireContactActor));
        structGen.addField("physx_PxShape_Pod* tireContactShape", "tireContactShape", "*mut PxShape",sizeof(physx::PxShape *), unsafe_offsetof(physx_PxWheelQueryResult_Pod, tireContactShape));
        structGen.addField("physx_PxMaterial_Pod* tireSurfaceMaterial", "tireSurfaceMaterial", "*const PxMaterial",sizeof(const physx::PxMaterial *), unsafe_offsetof(physx_PxWheelQueryResult_Pod, tireSurfaceMaterial));
        structGen.addField("uint32_t tireSurfaceType", "tireSurfaceType", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxWheelQueryResult_Pod, tireSurfaceType));
        structGen.addField("physx_PxVec3_Pod tireContactPoint", "tireContactPoint", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxWheelQueryResult_Pod, tireContactPoint));
        structGen.addField("physx_PxVec3_Pod tireContactNormal", "tireContactNormal", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxWheelQueryResult_Pod, tireContactNormal));
        structGen.addField("float tireFriction", "tireFriction", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxWheelQueryResult_Pod, tireFriction));
        structGen.addField("float suspJounce", "suspJounce", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxWheelQueryResult_Pod, suspJounce));
        structGen.addField("float suspSpringForce", "suspSpringForce", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxWheelQueryResult_Pod, suspSpringForce));
        structGen.addField("physx_PxVec3_Pod tireLongitudinalDir", "tireLongitudinalDir", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxWheelQueryResult_Pod, tireLongitudinalDir));
        structGen.addField("physx_PxVec3_Pod tireLateralDir", "tireLateralDir", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxWheelQueryResult_Pod, tireLateralDir));
        structGen.addField("float longitudinalSlip", "longitudinalSlip", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxWheelQueryResult_Pod, longitudinalSlip));
        structGen.addField("float lateralSlip", "lateralSlip", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxWheelQueryResult_Pod, lateralSlip));
        structGen.addField("float steerAngle", "steerAngle", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxWheelQueryResult_Pod, steerAngle));
        structGen.addField("physx_PxTransform_Pod localPose", "localPose", "PxTransform",sizeof(physx::PxTransform), unsafe_offsetof(physx_PxWheelQueryResult_Pod, localPose));
        structGen.endStruct(sizeof(physx::PxWheelQueryResult));
    }
};
physx_PxWheelQueryResult_Pod::dumpLayout(structGen);

struct physx_PxVehicleWheelConcurrentUpdateData_Pod: public physx::PxVehicleWheelConcurrentUpdateData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleWheelConcurrentUpdateData_Pod", "PxVehicleWheelConcurrentUpdateData");
        structGen.endStruct(sizeof(physx::PxVehicleWheelConcurrentUpdateData));
    }
};
physx_PxVehicleWheelConcurrentUpdateData_Pod::dumpLayout(structGen);

struct physx_PxVehicleConcurrentUpdateData_Pod: public physx::PxVehicleConcurrentUpdateData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleConcurrentUpdateData_Pod", "PxVehicleConcurrentUpdateData");
        structGen.addField("physx_PxVehicleWheelConcurrentUpdateData_Pod* concurrentWheelUpdates", "concurrentWheelUpdates", "*mut PxVehicleWheelConcurrentUpdateData",sizeof(physx::PxVehicleWheelConcurrentUpdateData *), unsafe_offsetof(physx_PxVehicleConcurrentUpdateData_Pod, concurrentWheelUpdates));
        structGen.addField("uint32_t nbConcurrentWheelUpdates", "nbConcurrentWheelUpdates", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxVehicleConcurrentUpdateData_Pod, nbConcurrentWheelUpdates));
        structGen.endStruct(sizeof(physx::PxVehicleConcurrentUpdateData));
    }
};
physx_PxVehicleConcurrentUpdateData_Pod::dumpLayout(structGen);

struct physx_PxVehicleWheelQueryResult_Pod: public physx::PxVehicleWheelQueryResult {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleWheelQueryResult_Pod", "PxVehicleWheelQueryResult");
        structGen.addField("physx_PxWheelQueryResult_Pod* wheelQueryResults", "wheelQueryResults", "*mut PxWheelQueryResult",sizeof(physx::PxWheelQueryResult *), unsafe_offsetof(physx_PxVehicleWheelQueryResult_Pod, wheelQueryResults));
        structGen.addField("uint32_t nbWheelQueryResults", "nbWheelQueryResults", "u32",sizeof(physx::PxU32), unsafe_offsetof(physx_PxVehicleWheelQueryResult_Pod, nbWheelQueryResults));
        structGen.endStruct(sizeof(physx::PxVehicleWheelQueryResult));
    }
};
physx_PxVehicleWheelQueryResult_Pod::dumpLayout(structGen);

struct physx_PxVehicleGraph_Pod: public physx::PxVehicleGraph {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleGraph_Pod", "PxVehicleGraph");
        structGen.endStruct(sizeof(physx::PxVehicleGraph));
    }
};
physx_PxVehicleGraph_Pod::dumpLayout(structGen);

struct physx_PxVehicleTelemetryData_Pod: public physx::PxVehicleTelemetryData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleTelemetryData_Pod", "PxVehicleTelemetryData");
        structGen.endStruct(sizeof(physx::PxVehicleTelemetryData));
    }
};
physx_PxVehicleTelemetryData_Pod::dumpLayout(structGen);

struct physx_PxVehicleDriveSimDataNW_Pod: public physx::PxVehicleDriveSimDataNW {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDriveSimDataNW_Pod", "PxVehicleDriveSimDataNW");
        structGen.addField("physx_PxVehicleEngineData_Pod mEngine", "mEngine", "PxVehicleEngineData",sizeof(physx::PxVehicleEngineData), unsafe_offsetof(physx_PxVehicleDriveSimDataNW_Pod, mEngine));
        structGen.addField("physx_PxVehicleGearsData_Pod mGears", "mGears", "PxVehicleGearsData",sizeof(physx::PxVehicleGearsData), unsafe_offsetof(physx_PxVehicleDriveSimDataNW_Pod, mGears));
        structGen.addField("physx_PxVehicleClutchData_Pod mClutch", "mClutch", "PxVehicleClutchData",sizeof(physx::PxVehicleClutchData), unsafe_offsetof(physx_PxVehicleDriveSimDataNW_Pod, mClutch));
        structGen.addField("physx_PxVehicleAutoBoxData_Pod mAutoBox", "mAutoBox", "PxVehicleAutoBoxData",sizeof(physx::PxVehicleAutoBoxData), unsafe_offsetof(physx_PxVehicleDriveSimDataNW_Pod, mAutoBox));
        structGen.endStruct(sizeof(physx::PxVehicleDriveSimDataNW));
    }
};
physx_PxVehicleDriveSimDataNW_Pod::dumpLayout(structGen);

struct physx_PxVehicleDriveNW_Pod: public physx::PxVehicleDriveNW {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDriveNW_Pod", "PxVehicleDriveNW");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxVehicleDriveNW_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxVehicleDriveNW_Pod, mBaseFlags));
        structGen.addField("physx_PxVehicleWheelsSimData_Pod mWheelsSimData", "mWheelsSimData", "PxVehicleWheelsSimData",sizeof(physx::PxVehicleWheelsSimData), unsafe_offsetof(physx_PxVehicleDriveNW_Pod, mWheelsSimData));
        structGen.addField("physx_PxVehicleWheelsDynData_Pod mWheelsDynData", "mWheelsDynData", "PxVehicleWheelsDynData",sizeof(physx::PxVehicleWheelsDynData), unsafe_offsetof(physx_PxVehicleDriveNW_Pod, mWheelsDynData));
        structGen.addField("physx_PxRigidDynamic_Pod* mActor", "mActor", "*mut PxRigidDynamic",sizeof(physx::PxRigidDynamic *), unsafe_offsetof(physx_PxVehicleDriveNW_Pod, mActor));
        structGen.addField("unsigned char mType", "mType", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxVehicleDriveNW_Pod, mType));
        structGen.addField("unsigned char mPad0[14]", "mPad0", "[u8; 14]",sizeof(physx::PxU8[14]), unsafe_offsetof(physx_PxVehicleDriveNW_Pod, mPad0));
        structGen.addField("physx_PxVehicleDriveDynData_Pod mDriveDynData", "mDriveDynData", "PxVehicleDriveDynData",sizeof(physx::PxVehicleDriveDynData), unsafe_offsetof(physx_PxVehicleDriveNW_Pod, mDriveDynData));
        structGen.addField("physx_PxVehicleDriveSimDataNW_Pod mDriveSimData", "mDriveSimData", "PxVehicleDriveSimDataNW",sizeof(physx::PxVehicleDriveSimDataNW), unsafe_offsetof(physx_PxVehicleDriveNW_Pod, mDriveSimData));
        structGen.endStruct(sizeof(physx::PxVehicleDriveNW));
    }
};
physx_PxVehicleDriveNW_Pod::dumpLayout(structGen);

struct physx_PxVehicleDrive4WRawInputData_Pod: public physx::PxVehicleDrive4WRawInputData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDrive4WRawInputData_Pod", "PxVehicleDrive4WRawInputData");
        structGen.endStruct(sizeof(physx::PxVehicleDrive4WRawInputData));
    }
};
physx_PxVehicleDrive4WRawInputData_Pod::dumpLayout(structGen);

struct physx_PxVehicleKeySmoothingData_Pod: public physx::PxVehicleKeySmoothingData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleKeySmoothingData_Pod", "PxVehicleKeySmoothingData");
        structGen.addField("float mRiseRates[16]", "mRiseRates", "[f32; 16]",sizeof(physx::PxReal[16]), unsafe_offsetof(physx_PxVehicleKeySmoothingData_Pod, mRiseRates));
        structGen.addField("float mFallRates[16]", "mFallRates", "[f32; 16]",sizeof(physx::PxReal[16]), unsafe_offsetof(physx_PxVehicleKeySmoothingData_Pod, mFallRates));
        structGen.endStruct(sizeof(physx::PxVehicleKeySmoothingData));
    }
};
physx_PxVehicleKeySmoothingData_Pod::dumpLayout(structGen);

structGen.passThroughC("struct PxFixedSizeLookupTable_8__Pod {\n    float mDataPairs[16];\n    uint32_t mNbDataPairs;\n    uint32_t mPad[3];\n};\n");
struct physx_PxVehiclePadSmoothingData_Pod: public physx::PxVehiclePadSmoothingData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehiclePadSmoothingData_Pod", "PxVehiclePadSmoothingData");
        structGen.addField("float mRiseRates[16]", "mRiseRates", "[f32; 16]",sizeof(physx::PxReal[16]), unsafe_offsetof(physx_PxVehiclePadSmoothingData_Pod, mRiseRates));
        structGen.addField("float mFallRates[16]", "mFallRates", "[f32; 16]",sizeof(physx::PxReal[16]), unsafe_offsetof(physx_PxVehiclePadSmoothingData_Pod, mFallRates));
        structGen.endStruct(sizeof(physx::PxVehiclePadSmoothingData));
    }
};
physx_PxVehiclePadSmoothingData_Pod::dumpLayout(structGen);

struct physx_PxVehicleDriveNWRawInputData_Pod: public physx::PxVehicleDriveNWRawInputData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDriveNWRawInputData_Pod", "PxVehicleDriveNWRawInputData");
        structGen.endStruct(sizeof(physx::PxVehicleDriveNWRawInputData));
    }
};
physx_PxVehicleDriveNWRawInputData_Pod::dumpLayout(structGen);

struct physx_PxVehicleDriveTankRawInputData_Pod: public physx::PxVehicleDriveTankRawInputData {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleDriveTankRawInputData_Pod", "PxVehicleDriveTankRawInputData");
        structGen.endStruct(sizeof(physx::PxVehicleDriveTankRawInputData));
    }
};
physx_PxVehicleDriveTankRawInputData_Pod::dumpLayout(structGen);

struct physx_PxVehicleCopyDynamicsMap_Pod: public physx::PxVehicleCopyDynamicsMap {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleCopyDynamicsMap_Pod", "PxVehicleCopyDynamicsMap");
        structGen.addField("unsigned char sourceWheelIds[20]", "sourceWheelIds", "[u8; 20]",sizeof(physx::PxU8[20]), unsafe_offsetof(physx_PxVehicleCopyDynamicsMap_Pod, sourceWheelIds));
        structGen.addField("unsigned char targetWheelIds[20]", "targetWheelIds", "[u8; 20]",sizeof(physx::PxU8[20]), unsafe_offsetof(physx_PxVehicleCopyDynamicsMap_Pod, targetWheelIds));
        structGen.endStruct(sizeof(physx::PxVehicleCopyDynamicsMap));
    }
};
physx_PxVehicleCopyDynamicsMap_Pod::dumpLayout(structGen);

struct physx_PxVehicleGraphChannelDesc_Pod: public physx::PxVehicleGraphChannelDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleGraphChannelDesc_Pod", "PxVehicleGraphChannelDesc");
        structGen.addField("float mMinY", "mMinY", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleGraphChannelDesc_Pod, mMinY));
        structGen.addField("float mMaxY", "mMaxY", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleGraphChannelDesc_Pod, mMaxY));
        structGen.addField("float mMidY", "mMidY", "f32",sizeof(physx::PxReal), unsafe_offsetof(physx_PxVehicleGraphChannelDesc_Pod, mMidY));
        structGen.addField("physx_PxVec3_Pod mColorLow", "mColorLow", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxVehicleGraphChannelDesc_Pod, mColorLow));
        structGen.addField("physx_PxVec3_Pod mColorHigh", "mColorHigh", "PxVec3",sizeof(physx::PxVec3), unsafe_offsetof(physx_PxVehicleGraphChannelDesc_Pod, mColorHigh));
        structGen.addField("char* mTitle", "mTitle", "*mut i8",sizeof(char *), unsafe_offsetof(physx_PxVehicleGraphChannelDesc_Pod, mTitle));
        structGen.endStruct(sizeof(physx::PxVehicleGraphChannelDesc));
    }
};
physx_PxVehicleGraphChannelDesc_Pod::dumpLayout(structGen);

struct physx_PxVehicleGraphDesc_Pod: public physx::PxVehicleGraphDesc {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleGraphDesc_Pod", "PxVehicleGraphDesc");
        structGen.endStruct(sizeof(physx::PxVehicleGraphDesc));
    }
};
physx_PxVehicleGraphDesc_Pod::dumpLayout(structGen);

struct physx_PxVehicleNoDrive_Pod: public physx::PxVehicleNoDrive {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxVehicleNoDrive_Pod", "PxVehicleNoDrive");
        structGen.addField("uint16_t mConcreteType", "mConcreteType", "u16",sizeof(physx::PxType), unsafe_offsetof(physx_PxVehicleNoDrive_Pod, mConcreteType));
        structGen.addField("physx_PxBaseFlags_Pod mBaseFlags", "mBaseFlags", "PxBaseFlags",sizeof(physx::PxBaseFlags), unsafe_offsetof(physx_PxVehicleNoDrive_Pod, mBaseFlags));
        structGen.addField("physx_PxVehicleWheelsSimData_Pod mWheelsSimData", "mWheelsSimData", "PxVehicleWheelsSimData",sizeof(physx::PxVehicleWheelsSimData), unsafe_offsetof(physx_PxVehicleNoDrive_Pod, mWheelsSimData));
        structGen.addField("physx_PxVehicleWheelsDynData_Pod mWheelsDynData", "mWheelsDynData", "PxVehicleWheelsDynData",sizeof(physx::PxVehicleWheelsDynData), unsafe_offsetof(physx_PxVehicleNoDrive_Pod, mWheelsDynData));
        structGen.addField("physx_PxRigidDynamic_Pod* mActor", "mActor", "*mut PxRigidDynamic",sizeof(physx::PxRigidDynamic *), unsafe_offsetof(physx_PxVehicleNoDrive_Pod, mActor));
        structGen.addField("unsigned char mType", "mType", "u8",sizeof(physx::PxU8), unsafe_offsetof(physx_PxVehicleNoDrive_Pod, mType));
        structGen.addField("unsigned char mPad0[14]", "mPad0", "[u8; 14]",sizeof(physx::PxU8[14]), unsafe_offsetof(physx_PxVehicleNoDrive_Pod, mPad0));
        structGen.endStruct(sizeof(physx::PxVehicleNoDrive));
    }
};
physx_PxVehicleNoDrive_Pod::dumpLayout(structGen);

struct physx_PxProfileScoped_Pod: public physx::PxProfileScoped {
    static void dumpLayout(PodStructGen& structGen) {
        structGen.beginStruct("physx_PxProfileScoped_Pod", "PxProfileScoped");
        structGen.addField("physx_PxProfilerCallback_Pod* mCallback", "mCallback", "*mut PxProfilerCallback",sizeof(physx::PxProfilerCallback *), unsafe_offsetof(physx_PxProfileScoped_Pod, mCallback));
        structGen.addField("char* mEventName", "mEventName", "*const i8",sizeof(const char *), unsafe_offsetof(physx_PxProfileScoped_Pod, mEventName));
        structGen.addField("void* mProfilerData", "mProfilerData", "*mut std::ffi::c_void",sizeof(void *), unsafe_offsetof(physx_PxProfileScoped_Pod, mProfilerData));
        structGen.addField("uint64_t mContextId", "mContextId", "usize",sizeof(uint64_t), unsafe_offsetof(physx_PxProfileScoped_Pod, mContextId));
        structGen.addField("bool mDetached", "mDetached", "bool",sizeof(bool), unsafe_offsetof(physx_PxProfileScoped_Pod, mDetached));
        structGen.endStruct(sizeof(physx::PxProfileScoped));
    }
};
physx_PxProfileScoped_Pod::dumpLayout(structGen);

structGen.passThroughC("struct physx_PxPvdTransport_Pod {\n    void* vtable_;\n};\n");
structGen.passThroughC("struct physx_PxPvdInstrumentationFlags_Pod {\n    unsigned char mBits;\n};\n");
structGen.finish();
}