#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 sg;
sg.pass_thru("struct physx_PxAllocatorCallback_Pod;\n");
sg.pass_thru("struct physx_PxErrorCallback_Pod;\n");
sg.pass_thru("struct physx_PxAssertHandler_Pod;\n");
sg.pass_thru("struct physx_PxInputStream_Pod;\n");
sg.pass_thru("struct physx_PxInputData_Pod;\n");
sg.pass_thru("struct physx_PxOutputStream_Pod;\n");
sg.pass_thru("struct physx_PxVec2_Pod;\n");
sg.pass_thru("struct physx_PxVec3_Pod;\n");
sg.pass_thru("struct physx_PxVec4_Pod;\n");
sg.pass_thru("struct physx_PxQuat_Pod;\n");
sg.pass_thru("struct physx_PxMat33_Pod;\n");
sg.pass_thru("struct physx_PxMat34_Pod;\n");
sg.pass_thru("struct physx_PxMat44_Pod;\n");
sg.pass_thru("struct physx_PxTransform_Pod;\n");
sg.pass_thru("struct physx_PxPlane_Pod;\n");
sg.pass_thru("struct physx_PxBounds3_Pod;\n");
sg.pass_thru("struct physx_PxAllocatorCallback_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxAssertHandler_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxAllocationListener_Pod;\n");
sg.pass_thru("struct physx_PxFoundation_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxProfilerCallback_Pod;\n");
struct physx_PxAllocator_Pod: public physx::PxAllocator {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxAllocator_Pod", "PxAllocator");
sg.end_struct(sizeof(physx::PxAllocator));
}
};
physx_PxAllocator_Pod::dump_layout(sg);
struct physx_PxRawAllocator_Pod: public physx::PxRawAllocator {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRawAllocator_Pod", "PxRawAllocator");
sg.end_struct(sizeof(physx::PxRawAllocator));
}
};
physx_PxRawAllocator_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxVirtualAllocatorCallback_Pod {\n void* vtable_;\n};\n");
struct physx_PxVirtualAllocator_Pod: public physx::PxVirtualAllocator {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxVirtualAllocator_Pod", "PxVirtualAllocator");
sg.end_struct(sizeof(physx::PxVirtualAllocator));
}
};
physx_PxVirtualAllocator_Pod::dump_layout(sg);
struct physx_PxUserAllocated_Pod: public physx::PxUserAllocated {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxUserAllocated_Pod", "PxUserAllocated");
sg.end_struct(sizeof(physx::PxUserAllocated));
}
};
physx_PxUserAllocated_Pod::dump_layout(sg);
sg.pass_thru("union physx_PxTempAllocatorChunk_Pod {\n physx_PxTempAllocatorChunk_Pod* mNext;\n uint32_t mIndex;\n uint8_t mPad[16];\n};\n");
struct physx_PxTempAllocator_Pod: public physx::PxTempAllocator {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTempAllocator_Pod", "PxTempAllocator");
sg.end_struct(sizeof(physx::PxTempAllocator));
}
};
physx_PxTempAllocator_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxLogTwo_Pod;\n");
sg.pass_thru("struct physx_PxUnConst_Pod;\n");
struct physx_PxBitAndByte_Pod: public physx::PxBitAndByte {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBitAndByte_Pod", "PxBitAndByte");
sg.end_struct(sizeof(physx::PxBitAndByte));
}
};
physx_PxBitAndByte_Pod::dump_layout(sg);
struct physx_PxBitMap_Pod: public physx::PxBitMap {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBitMap_Pod", "PxBitMap");
sg.end_struct(sizeof(physx::PxBitMap));
}
};
physx_PxBitMap_Pod::dump_layout(sg);
struct physx_PxVec3_Pod: public physx::PxVec3 {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxVec3_Pod", "PxVec3");
sg.add_field("float x", "x", "f32", sizeof(float), unsafe_offsetof(physx_PxVec3_Pod, x));
sg.add_field("float y", "y", "f32", sizeof(float), unsafe_offsetof(physx_PxVec3_Pod, y));
sg.add_field("float z", "z", "f32", sizeof(float), unsafe_offsetof(physx_PxVec3_Pod, z));
sg.end_struct(sizeof(physx::PxVec3));
}
};
physx_PxVec3_Pod::dump_layout(sg);
struct physx_PxVec3Padded_Pod: public physx::PxVec3Padded {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxVec3Padded_Pod", "PxVec3Padded");
sg.add_field("float x", "x", "f32", sizeof(float), unsafe_offsetof(physx_PxVec3Padded_Pod, x));
sg.add_field("float y", "y", "f32", sizeof(float), unsafe_offsetof(physx_PxVec3Padded_Pod, y));
sg.add_field("float z", "z", "f32", sizeof(float), unsafe_offsetof(physx_PxVec3Padded_Pod, z));
sg.add_field("uint32_t padding", "padding", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxVec3Padded_Pod, padding));
sg.end_struct(sizeof(physx::PxVec3Padded));
}
};
physx_PxVec3Padded_Pod::dump_layout(sg);
struct physx_PxQuat_Pod: public physx::PxQuat {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxQuat_Pod", "PxQuat");
sg.add_field("float x", "x", "f32", sizeof(float), unsafe_offsetof(physx_PxQuat_Pod, x));
sg.add_field("float y", "y", "f32", sizeof(float), unsafe_offsetof(physx_PxQuat_Pod, y));
sg.add_field("float z", "z", "f32", sizeof(float), unsafe_offsetof(physx_PxQuat_Pod, z));
sg.add_field("float w", "w", "f32", sizeof(float), unsafe_offsetof(physx_PxQuat_Pod, w));
sg.end_struct(sizeof(physx::PxQuat));
}
};
physx_PxQuat_Pod::dump_layout(sg);
struct physx_PxTransform_Pod: public physx::PxTransform {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTransform_Pod", "PxTransform");
sg.add_field("physx_PxQuat_Pod q", "q", "PxQuat", sizeof(physx::PxQuat), unsafe_offsetof(physx_PxTransform_Pod, q));
sg.add_field("physx_PxVec3_Pod p", "p", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTransform_Pod, p));
sg.end_struct(sizeof(physx::PxTransform));
}
};
physx_PxTransform_Pod::dump_layout(sg);
struct physx_PxTransformPadded_Pod: public physx::PxTransformPadded {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTransformPadded_Pod", "PxTransformPadded");
sg.add_field("physx_PxTransform_Pod transform", "transform", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxTransformPadded_Pod, transform));
sg.add_field("uint32_t padding", "padding", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxTransformPadded_Pod, padding));
sg.end_struct(sizeof(physx::PxTransformPadded));
}
};
physx_PxTransformPadded_Pod::dump_layout(sg);
struct physx_PxMat33_Pod: public physx::PxMat33 {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxMat33_Pod", "PxMat33");
sg.add_field("physx_PxVec3_Pod column0", "column0", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxMat33_Pod, column0));
sg.add_field("physx_PxVec3_Pod column1", "column1", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxMat33_Pod, column1));
sg.add_field("physx_PxVec3_Pod column2", "column2", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxMat33_Pod, column2));
sg.end_struct(sizeof(physx::PxMat33));
}
};
physx_PxMat33_Pod::dump_layout(sg);
struct physx_PxBounds3_Pod: public physx::PxBounds3 {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBounds3_Pod", "PxBounds3");
sg.add_field("physx_PxVec3_Pod minimum", "minimum", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxBounds3_Pod, minimum));
sg.add_field("physx_PxVec3_Pod maximum", "maximum", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxBounds3_Pod, maximum));
sg.end_struct(sizeof(physx::PxBounds3));
}
};
physx_PxBounds3_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxErrorCallback_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxAllocationListener_Pod {\n void* vtable_;\n};\n");
struct physx_PxBroadcastingAllocator_Pod: public physx::PxBroadcastingAllocator {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBroadcastingAllocator_Pod", "PxBroadcastingAllocator");
sg.end_struct(sizeof(physx::PxBroadcastingAllocator));
}
};
physx_PxBroadcastingAllocator_Pod::dump_layout(sg);
struct physx_PxBroadcastingErrorCallback_Pod: public physx::PxBroadcastingErrorCallback {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBroadcastingErrorCallback_Pod", "PxBroadcastingErrorCallback");
sg.end_struct(sizeof(physx::PxBroadcastingErrorCallback));
}
};
physx_PxBroadcastingErrorCallback_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxHash_Pod;\n");
sg.pass_thru("struct physx_PxInputStream_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxInputData_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxOutputStream_Pod {\n void* vtable_;\n};\n");
struct physx_PxVec4_Pod: public physx::PxVec4 {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxVec4_Pod", "PxVec4");
sg.add_field("float x", "x", "f32", sizeof(float), unsafe_offsetof(physx_PxVec4_Pod, x));
sg.add_field("float y", "y", "f32", sizeof(float), unsafe_offsetof(physx_PxVec4_Pod, y));
sg.add_field("float z", "z", "f32", sizeof(float), unsafe_offsetof(physx_PxVec4_Pod, z));
sg.add_field("float w", "w", "f32", sizeof(float), unsafe_offsetof(physx_PxVec4_Pod, w));
sg.end_struct(sizeof(physx::PxVec4));
}
};
physx_PxVec4_Pod::dump_layout(sg);
struct physx_PxMat44_Pod: public physx::PxMat44 {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxMat44_Pod", "PxMat44");
sg.add_field("physx_PxVec4_Pod column0", "column0", "PxVec4", sizeof(physx::PxVec4), unsafe_offsetof(physx_PxMat44_Pod, column0));
sg.add_field("physx_PxVec4_Pod column1", "column1", "PxVec4", sizeof(physx::PxVec4), unsafe_offsetof(physx_PxMat44_Pod, column1));
sg.add_field("physx_PxVec4_Pod column2", "column2", "PxVec4", sizeof(physx::PxVec4), unsafe_offsetof(physx_PxMat44_Pod, column2));
sg.add_field("physx_PxVec4_Pod column3", "column3", "PxVec4", sizeof(physx::PxVec4), unsafe_offsetof(physx_PxMat44_Pod, column3));
sg.end_struct(sizeof(physx::PxMat44));
}
};
physx_PxMat44_Pod::dump_layout(sg);
struct physx_PxPlane_Pod: public physx::PxPlane {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxPlane_Pod", "PxPlane");
sg.add_field("physx_PxVec3_Pod n", "n", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxPlane_Pod, n));
sg.add_field("float d", "d", "f32", sizeof(float), unsafe_offsetof(physx_PxPlane_Pod, d));
sg.end_struct(sizeof(physx::PxPlane));
}
};
physx_PxPlane_Pod::dump_layout(sg);
struct physx_Interpolation_Pod: public physx::Interpolation {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_Interpolation_Pod", "Interpolation");
sg.end_struct(sizeof(physx::Interpolation));
}
};
physx_Interpolation_Pod::dump_layout(sg);
struct physx_PxMutexImpl_Pod: public physx::PxMutexImpl {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxMutexImpl_Pod", "PxMutexImpl");
sg.end_struct(sizeof(physx::PxMutexImpl));
}
};
physx_PxMutexImpl_Pod::dump_layout(sg);
struct physx_PxReadWriteLock_Pod: public physx::PxReadWriteLock {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxReadWriteLock_Pod", "PxReadWriteLock");
sg.end_struct(sizeof(physx::PxReadWriteLock));
}
};
physx_PxReadWriteLock_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxProfilerCallback_Pod {\n void* vtable_;\n};\n");
struct physx_PxProfileScoped_Pod: public physx::PxProfileScoped {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxProfileScoped_Pod", "PxProfileScoped");
sg.add_field("physx_PxProfilerCallback_Pod* mCallback", "mCallback", "*mut PxProfilerCallback", sizeof(physx::PxProfilerCallback*), unsafe_offsetof(physx_PxProfileScoped_Pod, mCallback));
sg.add_field("char const* mEventName", "mEventName", "*const std::ffi::c_char", sizeof(char const*), unsafe_offsetof(physx_PxProfileScoped_Pod, mEventName));
sg.add_field("void* mProfilerData", "mProfilerData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxProfileScoped_Pod, mProfilerData));
sg.add_field("uint64_t mContextId", "mContextId", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxProfileScoped_Pod, mContextId));
sg.add_field("bool mDetached", "mDetached", "bool", sizeof(bool), unsafe_offsetof(physx_PxProfileScoped_Pod, mDetached));
sg.end_struct(sizeof(physx::PxProfileScoped));
}
};
physx_PxProfileScoped_Pod::dump_layout(sg);
struct physx_PxSListEntry_Pod: public physx::PxSListEntry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSListEntry_Pod", "PxSListEntry");
sg.end_struct(sizeof(physx::PxSListEntry));
}
};
physx_PxSListEntry_Pod::dump_layout(sg);
struct physx_PxSListImpl_Pod: public physx::PxSListImpl {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSListImpl_Pod", "PxSListImpl");
sg.end_struct(sizeof(physx::PxSListImpl));
}
};
physx_PxSListImpl_Pod::dump_layout(sg);
struct physx_PxSyncImpl_Pod: public physx::PxSyncImpl {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSyncImpl_Pod", "PxSyncImpl");
sg.end_struct(sizeof(physx::PxSyncImpl));
}
};
physx_PxSyncImpl_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxRunnable_Pod {\n void* vtable_;\n};\n");
struct physx_PxCounterFrequencyToTensOfNanos_Pod: public physx::PxCounterFrequencyToTensOfNanos {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxCounterFrequencyToTensOfNanos_Pod", "PxCounterFrequencyToTensOfNanos");
sg.add_field("uint64_t mNumerator", "mNumerator", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxCounterFrequencyToTensOfNanos_Pod, mNumerator));
sg.add_field("uint64_t mDenominator", "mDenominator", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxCounterFrequencyToTensOfNanos_Pod, mDenominator));
sg.end_struct(sizeof(physx::PxCounterFrequencyToTensOfNanos));
}
};
physx_PxCounterFrequencyToTensOfNanos_Pod::dump_layout(sg);
struct physx_PxTime_Pod: public physx::PxTime {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTime_Pod", "PxTime");
sg.end_struct(sizeof(physx::PxTime));
}
};
physx_PxTime_Pod::dump_layout(sg);
struct physx_PxVec2_Pod: public physx::PxVec2 {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxVec2_Pod", "PxVec2");
sg.add_field("float x", "x", "f32", sizeof(float), unsafe_offsetof(physx_PxVec2_Pod, x));
sg.add_field("float y", "y", "f32", sizeof(float), unsafe_offsetof(physx_PxVec2_Pod, y));
sg.end_struct(sizeof(physx::PxVec2));
}
};
physx_PxVec2_Pod::dump_layout(sg);
struct physx_PxStridedData_Pod: public physx::PxStridedData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxStridedData_Pod", "PxStridedData");
sg.add_field("uint32_t stride", "stride", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxStridedData_Pod, stride));
sg.add_field("void const* data", "data", "*const std::ffi::c_void", sizeof(void const*), unsafe_offsetof(physx_PxStridedData_Pod, data));
sg.end_struct(sizeof(physx::PxStridedData));
}
};
physx_PxStridedData_Pod::dump_layout(sg);
struct physx_PxBoundedData_Pod: public physx::PxBoundedData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBoundedData_Pod", "PxBoundedData");
sg.add_field("uint32_t stride", "stride", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBoundedData_Pod, stride));
sg.add_field("void const* data", "data", "*const std::ffi::c_void", sizeof(void const*), unsafe_offsetof(physx_PxBoundedData_Pod, data));
sg.add_field("uint32_t count", "count", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBoundedData_Pod, count));
sg.end_struct(sizeof(physx::PxBoundedData));
}
};
physx_PxBoundedData_Pod::dump_layout(sg);
struct physx_PxDebugPoint_Pod: public physx::PxDebugPoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDebugPoint_Pod", "PxDebugPoint");
sg.add_field("physx_PxVec3_Pod pos", "pos", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugPoint_Pod, pos));
sg.add_field("uint32_t color", "color", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxDebugPoint_Pod, color));
sg.end_struct(sizeof(physx::PxDebugPoint));
}
};
physx_PxDebugPoint_Pod::dump_layout(sg);
struct physx_PxDebugLine_Pod: public physx::PxDebugLine {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDebugLine_Pod", "PxDebugLine");
sg.add_field("physx_PxVec3_Pod pos0", "pos0", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugLine_Pod, pos0));
sg.add_field("uint32_t color0", "color0", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxDebugLine_Pod, color0));
sg.add_field("physx_PxVec3_Pod pos1", "pos1", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugLine_Pod, pos1));
sg.add_field("uint32_t color1", "color1", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxDebugLine_Pod, color1));
sg.end_struct(sizeof(physx::PxDebugLine));
}
};
physx_PxDebugLine_Pod::dump_layout(sg);
struct physx_PxDebugTriangle_Pod: public physx::PxDebugTriangle {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDebugTriangle_Pod", "PxDebugTriangle");
sg.add_field("physx_PxVec3_Pod pos0", "pos0", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugTriangle_Pod, pos0));
sg.add_field("uint32_t color0", "color0", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxDebugTriangle_Pod, color0));
sg.add_field("physx_PxVec3_Pod pos1", "pos1", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugTriangle_Pod, pos1));
sg.add_field("uint32_t color1", "color1", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxDebugTriangle_Pod, color1));
sg.add_field("physx_PxVec3_Pod pos2", "pos2", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugTriangle_Pod, pos2));
sg.add_field("uint32_t color2", "color2", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxDebugTriangle_Pod, color2));
sg.end_struct(sizeof(physx::PxDebugTriangle));
}
};
physx_PxDebugTriangle_Pod::dump_layout(sg);
struct physx_PxDebugText_Pod: public physx::PxDebugText {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDebugText_Pod", "PxDebugText");
sg.add_field("physx_PxVec3_Pod position", "position", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxDebugText_Pod, position));
sg.add_field("float size", "size", "f32", sizeof(float), unsafe_offsetof(physx_PxDebugText_Pod, size));
sg.add_field("uint32_t color", "color", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxDebugText_Pod, color));
sg.add_field("char const* string", "string", "*const std::ffi::c_char", sizeof(char const*), unsafe_offsetof(physx_PxDebugText_Pod, string));
sg.end_struct(sizeof(physx::PxDebugText));
}
};
physx_PxDebugText_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxRenderBuffer_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxBase_Pod;\n");
sg.pass_thru("struct physx_PxSerializationContext_Pod;\n");
sg.pass_thru("struct physx_PxRepXSerializer_Pod;\n");
sg.pass_thru("struct physx_PxSerializer_Pod;\n");
sg.pass_thru("struct physx_PxPhysics_Pod;\n");
sg.pass_thru("struct physx_PxCollection_Pod;\n");
sg.pass_thru("struct physx_PxProcessPxBaseCallback_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxSerializationContext_Pod {\n void* vtable_;\n};\n");
struct physx_PxDeserializationContext_Pod: public physx::PxDeserializationContext {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDeserializationContext_Pod", "PxDeserializationContext");
sg.end_struct(sizeof(physx::PxDeserializationContext));
}
};
physx_PxDeserializationContext_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxSerializationRegistry_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxCollection_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxTypeInfo_Pod;\n");
sg.pass_thru("struct physx_PxMaterial_Pod;\n");
sg.pass_thru("struct physx_PxFEMSoftBodyMaterial_Pod;\n");
sg.pass_thru("struct physx_PxFEMClothMaterial_Pod;\n");
sg.pass_thru("struct physx_PxPBDMaterial_Pod;\n");
sg.pass_thru("struct physx_PxFLIPMaterial_Pod;\n");
sg.pass_thru("struct physx_PxMPMMaterial_Pod;\n");
sg.pass_thru("struct physx_PxCustomMaterial_Pod;\n");
sg.pass_thru("struct physx_PxConvexMesh_Pod;\n");
sg.pass_thru("struct physx_PxTriangleMesh_Pod;\n");
sg.pass_thru("struct physx_PxBVH33TriangleMesh_Pod;\n");
sg.pass_thru("struct physx_PxBVH34TriangleMesh_Pod;\n");
sg.pass_thru("struct physx_PxTetrahedronMesh_Pod;\n");
sg.pass_thru("struct physx_PxHeightField_Pod;\n");
sg.pass_thru("struct physx_PxActor_Pod;\n");
sg.pass_thru("struct physx_PxRigidActor_Pod;\n");
sg.pass_thru("struct physx_PxRigidBody_Pod;\n");
sg.pass_thru("struct physx_PxRigidDynamic_Pod;\n");
sg.pass_thru("struct physx_PxRigidStatic_Pod;\n");
sg.pass_thru("struct physx_PxArticulationLink_Pod;\n");
sg.pass_thru("struct physx_PxArticulationJointReducedCoordinate_Pod;\n");
sg.pass_thru("struct physx_PxArticulationReducedCoordinate_Pod;\n");
sg.pass_thru("struct physx_PxAggregate_Pod;\n");
sg.pass_thru("struct physx_PxConstraint_Pod;\n");
sg.pass_thru("struct physx_PxShape_Pod;\n");
sg.pass_thru("struct physx_PxPruningStructure_Pod;\n");
sg.pass_thru("struct physx_PxParticleSystem_Pod;\n");
sg.pass_thru("struct physx_PxPBDParticleSystem_Pod;\n");
sg.pass_thru("struct physx_PxFLIPParticleSystem_Pod;\n");
sg.pass_thru("struct physx_PxMPMParticleSystem_Pod;\n");
sg.pass_thru("struct physx_PxCustomParticleSystem_Pod;\n");
sg.pass_thru("struct physx_PxSoftBody_Pod;\n");
sg.pass_thru("struct physx_PxFEMCloth_Pod;\n");
sg.pass_thru("struct physx_PxHairSystem_Pod;\n");
sg.pass_thru("struct physx_PxParticleBuffer_Pod;\n");
sg.pass_thru("struct physx_PxParticleAndDiffuseBuffer_Pod;\n");
sg.pass_thru("struct physx_PxParticleClothBuffer_Pod;\n");
sg.pass_thru("struct physx_PxParticleRigidBuffer_Pod;\n");
struct physx_PxBase_Pod: public physx::PxBase {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBase_Pod", "PxBase");
sg.end_struct(sizeof(physx::PxBase));
}
};
physx_PxBase_Pod::dump_layout(sg);
struct physx_PxRefCounted_Pod: public physx::PxRefCounted {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRefCounted_Pod", "PxRefCounted");
sg.end_struct(sizeof(physx::PxRefCounted));
}
};
physx_PxRefCounted_Pod::dump_layout(sg);
struct physx_PxTolerancesScale_Pod: public physx::PxTolerancesScale {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTolerancesScale_Pod", "PxTolerancesScale");
sg.add_field("float length", "length", "f32", sizeof(float), unsafe_offsetof(physx_PxTolerancesScale_Pod, length));
sg.add_field("float speed", "speed", "f32", sizeof(float), unsafe_offsetof(physx_PxTolerancesScale_Pod, speed));
sg.end_struct(sizeof(physx::PxTolerancesScale));
}
};
physx_PxTolerancesScale_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxStringTable_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxSerializer_Pod {\n void* vtable_;\n};\n");
struct physx_PxMetaDataEntry_Pod: public physx::PxMetaDataEntry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxMetaDataEntry_Pod", "PxMetaDataEntry");
sg.add_field("char const* type", "type_", "*const std::ffi::c_char", sizeof(char const*), unsafe_offsetof(physx_PxMetaDataEntry_Pod, type));
sg.add_field("char const* name", "name", "*const std::ffi::c_char", sizeof(char const*), unsafe_offsetof(physx_PxMetaDataEntry_Pod, name));
sg.add_field("uint32_t offset", "offset", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxMetaDataEntry_Pod, offset));
sg.add_field("uint32_t size", "size", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxMetaDataEntry_Pod, size));
sg.add_field("uint32_t count", "count", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxMetaDataEntry_Pod, count));
sg.add_field("uint32_t offsetSize", "offsetSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxMetaDataEntry_Pod, offsetSize));
sg.add_field("uint32_t flags", "flags", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxMetaDataEntry_Pod, flags));
sg.add_field("uint32_t alignment", "alignment", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxMetaDataEntry_Pod, alignment));
sg.end_struct(sizeof(physx::PxMetaDataEntry));
}
};
physx_PxMetaDataEntry_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxInsertionCallback_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxBaseTask_Pod;\n");
sg.pass_thru("struct physx_PxTask_Pod;\n");
sg.pass_thru("struct physx_PxLightCpuTask_Pod;\n");
sg.pass_thru("struct physx_PxCpuDispatcher_Pod;\n");
sg.pass_thru("struct physx_PxTaskManager_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxCpuDispatcher_Pod {\n void* vtable_;\n};\n");
struct physx_PxBaseTask_Pod: public physx::PxBaseTask {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBaseTask_Pod", "PxBaseTask");
sg.end_struct(sizeof(physx::PxBaseTask));
}
};
physx_PxBaseTask_Pod::dump_layout(sg);
struct physx_PxTask_Pod: public physx::PxTask {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTask_Pod", "PxTask");
sg.end_struct(sizeof(physx::PxTask));
}
};
physx_PxTask_Pod::dump_layout(sg);
struct physx_PxLightCpuTask_Pod: public physx::PxLightCpuTask {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxLightCpuTask_Pod", "PxLightCpuTask");
sg.end_struct(sizeof(physx::PxLightCpuTask));
}
};
physx_PxLightCpuTask_Pod::dump_layout(sg);
struct physx_PxGeometry_Pod: public physx::PxGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGeometry_Pod", "PxGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxGeometry_Pod, mTypePadding));
sg.end_struct(sizeof(physx::PxGeometry));
}
};
physx_PxGeometry_Pod::dump_layout(sg);
struct physx_PxBoxGeometry_Pod: public physx::PxBoxGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBoxGeometry_Pod", "PxBoxGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxGeometry_Pod, mTypePadding));
sg.add_field("physx_PxVec3_Pod halfExtents", "halfExtents", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxBoxGeometry_Pod, halfExtents));
sg.end_struct(sizeof(physx::PxBoxGeometry));
}
};
physx_PxBoxGeometry_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxBVHRaycastCallback_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxBVHOverlapCallback_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxBVHTraversalCallback_Pod {\n void* vtable_;\n};\n");
struct physx_PxBVH_Pod: public physx::PxBVH {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBVH_Pod", "PxBVH");
sg.end_struct(sizeof(physx::PxBVH));
}
};
physx_PxBVH_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxGeomIndexPair_Pod;\n");
struct physx_PxCapsuleGeometry_Pod: public physx::PxCapsuleGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxCapsuleGeometry_Pod", "PxCapsuleGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleGeometry_Pod, mTypePadding));
sg.add_field("float radius", "radius", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleGeometry_Pod, radius));
sg.add_field("float halfHeight", "halfHeight", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleGeometry_Pod, halfHeight));
sg.end_struct(sizeof(physx::PxCapsuleGeometry));
}
};
physx_PxCapsuleGeometry_Pod::dump_layout(sg);
struct physx_PxHullPolygon_Pod: public physx::PxHullPolygon {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxHullPolygon_Pod", "PxHullPolygon");
sg.add_field("float mPlane[4]", "mPlane", "[f32; 4]", sizeof(float[4]), unsafe_offsetof(physx_PxHullPolygon_Pod, mPlane));
sg.add_field("uint16_t mNbVerts", "mNbVerts", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxHullPolygon_Pod, mNbVerts));
sg.add_field("uint16_t mIndexBase", "mIndexBase", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxHullPolygon_Pod, mIndexBase));
sg.end_struct(sizeof(physx::PxHullPolygon));
}
};
physx_PxHullPolygon_Pod::dump_layout(sg);
struct physx_PxConvexMesh_Pod: public physx::PxConvexMesh {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxConvexMesh_Pod", "PxConvexMesh");
sg.end_struct(sizeof(physx::PxConvexMesh));
}
};
physx_PxConvexMesh_Pod::dump_layout(sg);
struct physx_PxMeshScale_Pod: public physx::PxMeshScale {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxMeshScale_Pod", "PxMeshScale");
sg.add_field("physx_PxVec3_Pod scale", "scale", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxMeshScale_Pod, scale));
sg.add_field("physx_PxQuat_Pod rotation", "rotation", "PxQuat", sizeof(physx::PxQuat), unsafe_offsetof(physx_PxMeshScale_Pod, rotation));
sg.end_struct(sizeof(physx::PxMeshScale));
}
};
physx_PxMeshScale_Pod::dump_layout(sg);
struct physx_PxConvexMeshGeometry_Pod: public physx::PxConvexMeshGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxConvexMeshGeometry_Pod", "PxConvexMeshGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxConvexMeshGeometry_Pod, mTypePadding));
sg.add_field("physx_PxMeshScale_Pod scale", "scale", "PxMeshScale", sizeof(physx::PxMeshScale), unsafe_offsetof(physx_PxConvexMeshGeometry_Pod, scale));
sg.add_field("physx_PxConvexMesh_Pod* convexMesh", "convexMesh", "*mut PxConvexMesh", sizeof(physx::PxConvexMesh*), unsafe_offsetof(physx_PxConvexMeshGeometry_Pod, convexMesh));
sg.add_field("uint8_t meshFlags", "meshFlags", "PxConvexMeshGeometryFlags", sizeof(physx::PxConvexMeshGeometryFlags), unsafe_offsetof(physx_PxConvexMeshGeometry_Pod, meshFlags));
sg.end_struct(sizeof(physx::PxConvexMeshGeometry));
}
};
physx_PxConvexMeshGeometry_Pod::dump_layout(sg);
struct physx_PxSphereGeometry_Pod: public physx::PxSphereGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSphereGeometry_Pod", "PxSphereGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxSphereGeometry_Pod, mTypePadding));
sg.add_field("float radius", "radius", "f32", sizeof(float), unsafe_offsetof(physx_PxSphereGeometry_Pod, radius));
sg.end_struct(sizeof(physx::PxSphereGeometry));
}
};
physx_PxSphereGeometry_Pod::dump_layout(sg);
struct physx_PxPlaneGeometry_Pod: public physx::PxPlaneGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxPlaneGeometry_Pod", "PxPlaneGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxPlaneGeometry_Pod, mTypePadding));
sg.end_struct(sizeof(physx::PxPlaneGeometry));
}
};
physx_PxPlaneGeometry_Pod::dump_layout(sg);
struct physx_PxTriangleMeshGeometry_Pod: public physx::PxTriangleMeshGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTriangleMeshGeometry_Pod", "PxTriangleMeshGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxTriangleMeshGeometry_Pod, mTypePadding));
sg.add_field("physx_PxMeshScale_Pod scale", "scale", "PxMeshScale", sizeof(physx::PxMeshScale), unsafe_offsetof(physx_PxTriangleMeshGeometry_Pod, scale));
sg.add_field("uint8_t meshFlags", "meshFlags", "PxMeshGeometryFlags", sizeof(physx::PxMeshGeometryFlags), unsafe_offsetof(physx_PxTriangleMeshGeometry_Pod, meshFlags));
sg.add_field("physx_PxTriangleMesh_Pod* triangleMesh", "triangleMesh", "*mut PxTriangleMesh", sizeof(physx::PxTriangleMesh*), unsafe_offsetof(physx_PxTriangleMeshGeometry_Pod, triangleMesh));
sg.end_struct(sizeof(physx::PxTriangleMeshGeometry));
}
};
physx_PxTriangleMeshGeometry_Pod::dump_layout(sg);
struct physx_PxHeightFieldGeometry_Pod: public physx::PxHeightFieldGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxHeightFieldGeometry_Pod", "PxHeightFieldGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, mTypePadding));
sg.add_field("physx_PxHeightField_Pod* heightField", "heightField", "*mut PxHeightField", sizeof(physx::PxHeightField*), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, heightField));
sg.add_field("float heightScale", "heightScale", "f32", sizeof(float), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, heightScale));
sg.add_field("float rowScale", "rowScale", "f32", sizeof(float), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, rowScale));
sg.add_field("float columnScale", "columnScale", "f32", sizeof(float), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, columnScale));
sg.add_field("uint8_t heightFieldFlags", "heightFieldFlags", "PxMeshGeometryFlags", sizeof(physx::PxMeshGeometryFlags), unsafe_offsetof(physx_PxHeightFieldGeometry_Pod, heightFieldFlags));
sg.end_struct(sizeof(physx::PxHeightFieldGeometry));
}
};
physx_PxHeightFieldGeometry_Pod::dump_layout(sg);
struct physx_PxParticleSystemGeometry_Pod: public physx::PxParticleSystemGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxParticleSystemGeometry_Pod", "PxParticleSystemGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxParticleSystemGeometry_Pod, mTypePadding));
sg.add_field("int32_t mSolverType", "mSolverType", "PxParticleSolverType", sizeof(physx::PxParticleSolverType::Enum), unsafe_offsetof(physx_PxParticleSystemGeometry_Pod, mSolverType));
sg.end_struct(sizeof(physx::PxParticleSystemGeometry));
}
};
physx_PxParticleSystemGeometry_Pod::dump_layout(sg);
struct physx_PxHairSystemGeometry_Pod: public physx::PxHairSystemGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxHairSystemGeometry_Pod", "PxHairSystemGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxHairSystemGeometry_Pod, mTypePadding));
sg.end_struct(sizeof(physx::PxHairSystemGeometry));
}
};
physx_PxHairSystemGeometry_Pod::dump_layout(sg);
struct physx_PxTetrahedronMeshGeometry_Pod: public physx::PxTetrahedronMeshGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTetrahedronMeshGeometry_Pod", "PxTetrahedronMeshGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxTetrahedronMeshGeometry_Pod, mTypePadding));
sg.add_field("physx_PxTetrahedronMesh_Pod* tetrahedronMesh", "tetrahedronMesh", "*mut PxTetrahedronMesh", sizeof(physx::PxTetrahedronMesh*), unsafe_offsetof(physx_PxTetrahedronMeshGeometry_Pod, tetrahedronMesh));
sg.end_struct(sizeof(physx::PxTetrahedronMeshGeometry));
}
};
physx_PxTetrahedronMeshGeometry_Pod::dump_layout(sg);
struct physx_PxQueryHit_Pod: public physx::PxQueryHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxQueryHit_Pod", "PxQueryHit");
sg.add_field("uint32_t faceIndex", "faceIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxQueryHit_Pod, faceIndex));
sg.end_struct(sizeof(physx::PxQueryHit));
}
};
physx_PxQueryHit_Pod::dump_layout(sg);
struct physx_PxLocationHit_Pod: public physx::PxLocationHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxLocationHit_Pod", "PxLocationHit");
sg.add_field("uint32_t faceIndex", "faceIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxLocationHit_Pod, faceIndex));
sg.add_field("uint16_t flags", "flags", "PxHitFlags", sizeof(physx::PxHitFlags), unsafe_offsetof(physx_PxLocationHit_Pod, flags));
sg.add_field("physx_PxVec3_Pod position", "position", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxLocationHit_Pod, position));
sg.add_field("physx_PxVec3_Pod normal", "normal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxLocationHit_Pod, normal));
sg.add_field("float distance", "distance", "f32", sizeof(float), unsafe_offsetof(physx_PxLocationHit_Pod, distance));
sg.end_struct(sizeof(physx::PxLocationHit));
}
};
physx_PxLocationHit_Pod::dump_layout(sg);
struct physx_PxGeomRaycastHit_Pod: public physx::PxGeomRaycastHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGeomRaycastHit_Pod", "PxGeomRaycastHit");
sg.add_field("uint32_t faceIndex", "faceIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxGeomRaycastHit_Pod, faceIndex));
sg.add_field("uint16_t flags", "flags", "PxHitFlags", sizeof(physx::PxHitFlags), unsafe_offsetof(physx_PxGeomRaycastHit_Pod, flags));
sg.add_field("physx_PxVec3_Pod position", "position", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxGeomRaycastHit_Pod, position));
sg.add_field("physx_PxVec3_Pod normal", "normal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxGeomRaycastHit_Pod, normal));
sg.add_field("float distance", "distance", "f32", sizeof(float), unsafe_offsetof(physx_PxGeomRaycastHit_Pod, distance));
sg.add_field("float u", "u", "f32", sizeof(float), unsafe_offsetof(physx_PxGeomRaycastHit_Pod, u));
sg.add_field("float v", "v", "f32", sizeof(float), unsafe_offsetof(physx_PxGeomRaycastHit_Pod, v));
sg.end_struct(sizeof(physx::PxGeomRaycastHit));
}
};
physx_PxGeomRaycastHit_Pod::dump_layout(sg);
struct physx_PxGeomOverlapHit_Pod: public physx::PxGeomOverlapHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGeomOverlapHit_Pod", "PxGeomOverlapHit");
sg.add_field("uint32_t faceIndex", "faceIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxGeomOverlapHit_Pod, faceIndex));
sg.end_struct(sizeof(physx::PxGeomOverlapHit));
}
};
physx_PxGeomOverlapHit_Pod::dump_layout(sg);
struct physx_PxGeomSweepHit_Pod: public physx::PxGeomSweepHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGeomSweepHit_Pod", "PxGeomSweepHit");
sg.add_field("uint32_t faceIndex", "faceIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxGeomSweepHit_Pod, faceIndex));
sg.add_field("uint16_t flags", "flags", "PxHitFlags", sizeof(physx::PxHitFlags), unsafe_offsetof(physx_PxGeomSweepHit_Pod, flags));
sg.add_field("physx_PxVec3_Pod position", "position", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxGeomSweepHit_Pod, position));
sg.add_field("physx_PxVec3_Pod normal", "normal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxGeomSweepHit_Pod, normal));
sg.add_field("float distance", "distance", "f32", sizeof(float), unsafe_offsetof(physx_PxGeomSweepHit_Pod, distance));
sg.end_struct(sizeof(physx::PxGeomSweepHit));
}
};
physx_PxGeomSweepHit_Pod::dump_layout(sg);
struct physx_PxGeomIndexPair_Pod: public physx::PxGeomIndexPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGeomIndexPair_Pod", "PxGeomIndexPair");
sg.add_field("uint32_t id0", "id0", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxGeomIndexPair_Pod, id0));
sg.add_field("uint32_t id1", "id1", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxGeomIndexPair_Pod, id1));
sg.end_struct(sizeof(physx::PxGeomIndexPair));
}
};
physx_PxGeomIndexPair_Pod::dump_layout(sg);
struct physx_PxQueryThreadContext_Pod: public physx::PxQueryThreadContext {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxQueryThreadContext_Pod", "PxQueryThreadContext");
sg.end_struct(sizeof(physx::PxQueryThreadContext));
}
};
physx_PxQueryThreadContext_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxContactBuffer_Pod;\n");
sg.pass_thru("struct physx_PxRenderOutput_Pod;\n");
sg.pass_thru("struct physx_PxMassProperties_Pod;\n");
struct physx_PxCustomGeometryType_Pod: public physx::PxCustomGeometryType {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxCustomGeometryType_Pod", "PxCustomGeometryType");
sg.end_struct(sizeof(physx::PxCustomGeometryType));
}
};
physx_PxCustomGeometryType_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxCustomGeometryCallbacks_Pod {\n void* vtable_;\n};\n");
struct physx_PxCustomGeometry_Pod: public physx::PxCustomGeometry {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxCustomGeometry_Pod", "PxCustomGeometry");
sg.add_field("float mTypePadding", "mTypePadding", "f32", sizeof(float), unsafe_offsetof(physx_PxCustomGeometry_Pod, mTypePadding));
sg.add_field("physx_PxCustomGeometryCallbacks_Pod* callbacks", "callbacks", "*mut PxCustomGeometryCallbacks", sizeof(physx::PxCustomGeometryCallbacks*), unsafe_offsetof(physx_PxCustomGeometry_Pod, callbacks));
sg.end_struct(sizeof(physx::PxCustomGeometry));
}
};
physx_PxCustomGeometry_Pod::dump_layout(sg);
struct physx_PxGeometryHolder_Pod: public physx::PxGeometryHolder {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGeometryHolder_Pod", "PxGeometryHolder");
sg.end_struct(sizeof(physx::PxGeometryHolder));
}
};
physx_PxGeometryHolder_Pod::dump_layout(sg);
struct physx_PxGeometryQuery_Pod: public physx::PxGeometryQuery {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGeometryQuery_Pod", "PxGeometryQuery");
sg.end_struct(sizeof(physx::PxGeometryQuery));
}
};
physx_PxGeometryQuery_Pod::dump_layout(sg);
struct physx_PxHeightFieldSample_Pod: public physx::PxHeightFieldSample {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxHeightFieldSample_Pod", "PxHeightFieldSample");
sg.add_field("int16_t height", "height", "i16", sizeof(int16_t), unsafe_offsetof(physx_PxHeightFieldSample_Pod, height));
sg.add_field("physx_PxBitAndByte_Pod materialIndex0", "materialIndex0", "PxBitAndByte", sizeof(physx::PxBitAndByte), unsafe_offsetof(physx_PxHeightFieldSample_Pod, materialIndex0));
sg.add_field("physx_PxBitAndByte_Pod materialIndex1", "materialIndex1", "PxBitAndByte", sizeof(physx::PxBitAndByte), unsafe_offsetof(physx_PxHeightFieldSample_Pod, materialIndex1));
sg.end_struct(sizeof(physx::PxHeightFieldSample));
}
};
physx_PxHeightFieldSample_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxHeightFieldDesc_Pod;\n");
struct physx_PxHeightField_Pod: public physx::PxHeightField {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxHeightField_Pod", "PxHeightField");
sg.end_struct(sizeof(physx::PxHeightField));
}
};
physx_PxHeightField_Pod::dump_layout(sg);
struct physx_PxHeightFieldDesc_Pod: public physx::PxHeightFieldDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxHeightFieldDesc_Pod", "PxHeightFieldDesc");
sg.add_field("uint32_t nbRows", "nbRows", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, nbRows));
sg.add_field("uint32_t nbColumns", "nbColumns", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, nbColumns));
sg.add_field("int32_t format", "format", "PxHeightFieldFormat", sizeof(physx::PxHeightFieldFormat::Enum), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, format));
sg.add_field("physx_PxStridedData_Pod samples", "samples", "PxStridedData", sizeof(physx::PxStridedData), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, samples));
sg.add_field("float convexEdgeThreshold", "convexEdgeThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, convexEdgeThreshold));
sg.add_field("uint16_t flags", "flags", "PxHeightFieldFlags", sizeof(physx::PxHeightFieldFlags), unsafe_offsetof(physx_PxHeightFieldDesc_Pod, flags));
sg.end_struct(sizeof(physx::PxHeightFieldDesc));
}
};
physx_PxHeightFieldDesc_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxTriangle_Pod;\n");
struct physx_PxMeshQuery_Pod: public physx::PxMeshQuery {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxMeshQuery_Pod", "PxMeshQuery");
sg.end_struct(sizeof(physx::PxMeshQuery));
}
};
physx_PxMeshQuery_Pod::dump_layout(sg);
struct physx_PxSimpleTriangleMesh_Pod: public physx::PxSimpleTriangleMesh {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSimpleTriangleMesh_Pod", "PxSimpleTriangleMesh");
sg.add_field("physx_PxBoundedData_Pod points", "points", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxSimpleTriangleMesh_Pod, points));
sg.add_field("physx_PxBoundedData_Pod triangles", "triangles", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxSimpleTriangleMesh_Pod, triangles));
sg.add_field("uint16_t flags", "flags", "PxMeshFlags", sizeof(physx::PxMeshFlags), unsafe_offsetof(physx_PxSimpleTriangleMesh_Pod, flags));
sg.end_struct(sizeof(physx::PxSimpleTriangleMesh));
}
};
physx_PxSimpleTriangleMesh_Pod::dump_layout(sg);
struct physx_PxTriangle_Pod: public physx::PxTriangle {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTriangle_Pod", "PxTriangle");
sg.add_field("physx_PxVec3_Pod verts[3]", "verts", "[PxVec3; 3]", sizeof(physx::PxVec3[3]), unsafe_offsetof(physx_PxTriangle_Pod, verts));
sg.end_struct(sizeof(physx::PxTriangle));
}
};
physx_PxTriangle_Pod::dump_layout(sg);
struct physx_PxTrianglePadded_Pod: public physx::PxTrianglePadded {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTrianglePadded_Pod", "PxTrianglePadded");
sg.add_field("physx_PxVec3_Pod verts[3]", "verts", "[PxVec3; 3]", sizeof(physx::PxVec3[3]), unsafe_offsetof(physx_PxTrianglePadded_Pod, verts));
sg.add_field("uint32_t padding", "padding", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxTrianglePadded_Pod, padding));
sg.end_struct(sizeof(physx::PxTrianglePadded));
}
};
physx_PxTrianglePadded_Pod::dump_layout(sg);
struct physx_PxTriangleMesh_Pod: public physx::PxTriangleMesh {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTriangleMesh_Pod", "PxTriangleMesh");
sg.end_struct(sizeof(physx::PxTriangleMesh));
}
};
physx_PxTriangleMesh_Pod::dump_layout(sg);
struct physx_PxBVH34TriangleMesh_Pod: public physx::PxBVH34TriangleMesh {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBVH34TriangleMesh_Pod", "PxBVH34TriangleMesh");
sg.end_struct(sizeof(physx::PxBVH34TriangleMesh));
}
};
physx_PxBVH34TriangleMesh_Pod::dump_layout(sg);
struct physx_PxTetrahedron_Pod: public physx::PxTetrahedron {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTetrahedron_Pod", "PxTetrahedron");
sg.add_field("physx_PxVec3_Pod verts[4]", "verts", "[PxVec3; 4]", sizeof(physx::PxVec3[4]), unsafe_offsetof(physx_PxTetrahedron_Pod, verts));
sg.end_struct(sizeof(physx::PxTetrahedron));
}
};
physx_PxTetrahedron_Pod::dump_layout(sg);
struct physx_PxSoftBodyAuxData_Pod: public physx::PxSoftBodyAuxData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSoftBodyAuxData_Pod", "PxSoftBodyAuxData");
sg.end_struct(sizeof(physx::PxSoftBodyAuxData));
}
};
physx_PxSoftBodyAuxData_Pod::dump_layout(sg);
struct physx_PxTetrahedronMesh_Pod: public physx::PxTetrahedronMesh {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTetrahedronMesh_Pod", "PxTetrahedronMesh");
sg.end_struct(sizeof(physx::PxTetrahedronMesh));
}
};
physx_PxTetrahedronMesh_Pod::dump_layout(sg);
struct physx_PxSoftBodyMesh_Pod: public physx::PxSoftBodyMesh {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSoftBodyMesh_Pod", "PxSoftBodyMesh");
sg.end_struct(sizeof(physx::PxSoftBodyMesh));
}
};
physx_PxSoftBodyMesh_Pod::dump_layout(sg);
struct physx_PxCollisionMeshMappingData_Pod: public physx::PxCollisionMeshMappingData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxCollisionMeshMappingData_Pod", "PxCollisionMeshMappingData");
sg.end_struct(sizeof(physx::PxCollisionMeshMappingData));
}
};
physx_PxCollisionMeshMappingData_Pod::dump_layout(sg);
struct physx_PxSoftBodyCollisionData_Pod: public physx::PxSoftBodyCollisionData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSoftBodyCollisionData_Pod", "PxSoftBodyCollisionData");
sg.end_struct(sizeof(physx::PxSoftBodyCollisionData));
}
};
physx_PxSoftBodyCollisionData_Pod::dump_layout(sg);
struct physx_PxTetrahedronMeshData_Pod: public physx::PxTetrahedronMeshData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTetrahedronMeshData_Pod", "PxTetrahedronMeshData");
sg.end_struct(sizeof(physx::PxTetrahedronMeshData));
}
};
physx_PxTetrahedronMeshData_Pod::dump_layout(sg);
struct physx_PxSoftBodySimulationData_Pod: public physx::PxSoftBodySimulationData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSoftBodySimulationData_Pod", "PxSoftBodySimulationData");
sg.end_struct(sizeof(physx::PxSoftBodySimulationData));
}
};
physx_PxSoftBodySimulationData_Pod::dump_layout(sg);
struct physx_PxCollisionTetrahedronMeshData_Pod: public physx::PxCollisionTetrahedronMeshData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxCollisionTetrahedronMeshData_Pod", "PxCollisionTetrahedronMeshData");
sg.end_struct(sizeof(physx::PxCollisionTetrahedronMeshData));
}
};
physx_PxCollisionTetrahedronMeshData_Pod::dump_layout(sg);
struct physx_PxSimulationTetrahedronMeshData_Pod: public physx::PxSimulationTetrahedronMeshData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSimulationTetrahedronMeshData_Pod", "PxSimulationTetrahedronMeshData");
sg.end_struct(sizeof(physx::PxSimulationTetrahedronMeshData));
}
};
physx_PxSimulationTetrahedronMeshData_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxScene_Pod;\n");
struct physx_PxActor_Pod: public physx::PxActor {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxActor_Pod", "PxActor");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxActor_Pod, userData));
sg.end_struct(sizeof(physx::PxActor));
}
};
physx_PxActor_Pod::dump_layout(sg);
struct physx_PxAggregate_Pod: public physx::PxAggregate {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxAggregate_Pod", "PxAggregate");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxAggregate_Pod, userData));
sg.end_struct(sizeof(physx::PxAggregate));
}
};
physx_PxAggregate_Pod::dump_layout(sg);
struct physx_PxSpringModifiers_Pod: public physx::PxSpringModifiers {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSpringModifiers_Pod", "PxSpringModifiers");
sg.add_field("float stiffness", "stiffness", "f32", sizeof(float), unsafe_offsetof(physx_PxSpringModifiers_Pod, stiffness));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxSpringModifiers_Pod, damping));
sg.end_struct(sizeof(physx::PxSpringModifiers));
}
};
physx_PxSpringModifiers_Pod::dump_layout(sg);
struct physx_PxRestitutionModifiers_Pod: public physx::PxRestitutionModifiers {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRestitutionModifiers_Pod", "PxRestitutionModifiers");
sg.add_field("float restitution", "restitution", "f32", sizeof(float), unsafe_offsetof(physx_PxRestitutionModifiers_Pod, restitution));
sg.add_field("float velocityThreshold", "velocityThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxRestitutionModifiers_Pod, velocityThreshold));
sg.end_struct(sizeof(physx::PxRestitutionModifiers));
}
};
physx_PxRestitutionModifiers_Pod::dump_layout(sg);
sg.pass_thru("union physx_Px1DConstraintMods_Pod {\n physx_PxSpringModifiers_Pod spring;\n physx_PxRestitutionModifiers_Pod bounce;\n};\n");
struct physx_Px1DConstraint_Pod: public physx::Px1DConstraint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_Px1DConstraint_Pod", "Px1DConstraint");
sg.add_field("physx_PxVec3_Pod linear0", "linear0", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_Px1DConstraint_Pod, linear0));
sg.add_field("float geometricError", "geometricError", "f32", sizeof(float), unsafe_offsetof(physx_Px1DConstraint_Pod, geometricError));
sg.add_field("physx_PxVec3_Pod angular0", "angular0", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_Px1DConstraint_Pod, angular0));
sg.add_field("float velocityTarget", "velocityTarget", "f32", sizeof(float), unsafe_offsetof(physx_Px1DConstraint_Pod, velocityTarget));
sg.add_field("physx_PxVec3_Pod linear1", "linear1", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_Px1DConstraint_Pod, linear1));
sg.add_field("float minImpulse", "minImpulse", "f32", sizeof(float), unsafe_offsetof(physx_Px1DConstraint_Pod, minImpulse));
sg.add_field("physx_PxVec3_Pod angular1", "angular1", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_Px1DConstraint_Pod, angular1));
sg.add_field("float maxImpulse", "maxImpulse", "f32", sizeof(float), unsafe_offsetof(physx_Px1DConstraint_Pod, maxImpulse));
sg.add_field("physx_Px1DConstraintMods_Pod mods", "mods", "Px1DConstraintMods", sizeof(physx::Px1DConstraintMods), unsafe_offsetof(physx_Px1DConstraint_Pod, mods));
sg.add_field("float forInternalUse", "forInternalUse", "f32", sizeof(float), unsafe_offsetof(physx_Px1DConstraint_Pod, forInternalUse));
sg.add_field("uint16_t flags", "flags", "u16", sizeof(uint16_t), unsafe_offsetof(physx_Px1DConstraint_Pod, flags));
sg.add_field("uint16_t solveHint", "solveHint", "u16", sizeof(uint16_t), unsafe_offsetof(physx_Px1DConstraint_Pod, solveHint));
sg.end_struct(sizeof(physx::Px1DConstraint));
}
};
physx_Px1DConstraint_Pod::dump_layout(sg);
struct physx_PxConstraintInvMassScale_Pod: public physx::PxConstraintInvMassScale {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxConstraintInvMassScale_Pod", "PxConstraintInvMassScale");
sg.add_field("float linear0", "linear0", "f32", sizeof(float), unsafe_offsetof(physx_PxConstraintInvMassScale_Pod, linear0));
sg.add_field("float angular0", "angular0", "f32", sizeof(float), unsafe_offsetof(physx_PxConstraintInvMassScale_Pod, angular0));
sg.add_field("float linear1", "linear1", "f32", sizeof(float), unsafe_offsetof(physx_PxConstraintInvMassScale_Pod, linear1));
sg.add_field("float angular1", "angular1", "f32", sizeof(float), unsafe_offsetof(physx_PxConstraintInvMassScale_Pod, angular1));
sg.end_struct(sizeof(physx::PxConstraintInvMassScale));
}
};
physx_PxConstraintInvMassScale_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxConstraintVisualizer_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxConstraintConnector_Pod {\n void* vtable_;\n};\n");
struct physx_PxContactPoint_Pod: public physx::PxContactPoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactPoint_Pod", "PxContactPoint");
sg.add_field("physx_PxVec3_Pod normal", "normal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactPoint_Pod, normal));
sg.add_field("float separation", "separation", "f32", sizeof(float), unsafe_offsetof(physx_PxContactPoint_Pod, separation));
sg.add_field("physx_PxVec3_Pod point", "point", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactPoint_Pod, point));
sg.add_field("float maxImpulse", "maxImpulse", "f32", sizeof(float), unsafe_offsetof(physx_PxContactPoint_Pod, maxImpulse));
sg.add_field("physx_PxVec3_Pod targetVel", "targetVel", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactPoint_Pod, targetVel));
sg.add_field("float staticFriction", "staticFriction", "f32", sizeof(float), unsafe_offsetof(physx_PxContactPoint_Pod, staticFriction));
sg.add_field("uint8_t materialFlags", "materialFlags", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxContactPoint_Pod, materialFlags));
sg.add_field("uint32_t internalFaceIndex1", "internalFaceIndex1", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactPoint_Pod, internalFaceIndex1));
sg.add_field("float dynamicFriction", "dynamicFriction", "f32", sizeof(float), unsafe_offsetof(physx_PxContactPoint_Pod, dynamicFriction));
sg.add_field("float restitution", "restitution", "f32", sizeof(float), unsafe_offsetof(physx_PxContactPoint_Pod, restitution));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxContactPoint_Pod, damping));
sg.end_struct(sizeof(physx::PxContactPoint));
}
};
physx_PxContactPoint_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxTGSSolverBodyVel_Pod;\n");
struct physx_PxSolverBody_Pod: public physx::PxSolverBody {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSolverBody_Pod", "PxSolverBody");
sg.add_field("physx_PxVec3_Pod linearVelocity", "linearVelocity", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSolverBody_Pod, linearVelocity));
sg.add_field("uint16_t maxSolverNormalProgress", "maxSolverNormalProgress", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxSolverBody_Pod, maxSolverNormalProgress));
sg.add_field("uint16_t maxSolverFrictionProgress", "maxSolverFrictionProgress", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxSolverBody_Pod, maxSolverFrictionProgress));
sg.add_field("physx_PxVec3_Pod angularState", "angularState", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSolverBody_Pod, angularState));
sg.add_field("uint32_t solverProgress", "solverProgress", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSolverBody_Pod, solverProgress));
sg.end_struct(sizeof(physx::PxSolverBody));
}
};
physx_PxSolverBody_Pod::dump_layout(sg);
struct physx_PxSolverBodyData_Pod: public physx::PxSolverBodyData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSolverBodyData_Pod", "PxSolverBodyData");
sg.add_field("physx_PxVec3_Pod linearVelocity", "linearVelocity", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSolverBodyData_Pod, linearVelocity));
sg.add_field("float invMass", "invMass", "f32", sizeof(float), unsafe_offsetof(physx_PxSolverBodyData_Pod, invMass));
sg.add_field("physx_PxVec3_Pod angularVelocity", "angularVelocity", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSolverBodyData_Pod, angularVelocity));
sg.add_field("float reportThreshold", "reportThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxSolverBodyData_Pod, reportThreshold));
sg.add_field("physx_PxMat33_Pod sqrtInvInertia", "sqrtInvInertia", "PxMat33", sizeof(physx::PxMat33), unsafe_offsetof(physx_PxSolverBodyData_Pod, sqrtInvInertia));
sg.add_field("float penBiasClamp", "penBiasClamp", "f32", sizeof(float), unsafe_offsetof(physx_PxSolverBodyData_Pod, penBiasClamp));
sg.add_field("uint32_t nodeIndex", "nodeIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSolverBodyData_Pod, nodeIndex));
sg.add_field("float maxContactImpulse", "maxContactImpulse", "f32", sizeof(float), unsafe_offsetof(physx_PxSolverBodyData_Pod, maxContactImpulse));
sg.add_field("physx_PxTransform_Pod body2World", "body2World", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxSolverBodyData_Pod, body2World));
sg.add_field("uint16_t pad", "pad", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxSolverBodyData_Pod, pad));
sg.end_struct(sizeof(physx::PxSolverBodyData));
}
};
physx_PxSolverBodyData_Pod::dump_layout(sg);
struct physx_PxConstraintBatchHeader_Pod: public physx::PxConstraintBatchHeader {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxConstraintBatchHeader_Pod", "PxConstraintBatchHeader");
sg.add_field("uint32_t startIndex", "startIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxConstraintBatchHeader_Pod, startIndex));
sg.add_field("uint16_t stride", "stride", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxConstraintBatchHeader_Pod, stride));
sg.add_field("uint16_t constraintType", "constraintType", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxConstraintBatchHeader_Pod, constraintType));
sg.end_struct(sizeof(physx::PxConstraintBatchHeader));
}
};
physx_PxConstraintBatchHeader_Pod::dump_layout(sg);
struct physx_PxSolverConstraintDesc_Pod: public physx::PxSolverConstraintDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSolverConstraintDesc_Pod", "PxSolverConstraintDesc");
sg.add_field("uint32_t bodyADataIndex", "bodyADataIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSolverConstraintDesc_Pod, bodyADataIndex));
sg.add_field("uint32_t bodyBDataIndex", "bodyBDataIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSolverConstraintDesc_Pod, bodyBDataIndex));
sg.add_field("uint32_t linkIndexA", "linkIndexA", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSolverConstraintDesc_Pod, linkIndexA));
sg.add_field("uint32_t linkIndexB", "linkIndexB", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSolverConstraintDesc_Pod, linkIndexB));
sg.add_field("uint8_t* constraint", "constraint", "*mut u8", sizeof(uint8_t*), unsafe_offsetof(physx_PxSolverConstraintDesc_Pod, constraint));
sg.add_field("void* writeBack", "writeBack", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxSolverConstraintDesc_Pod, writeBack));
sg.add_field("uint16_t progressA", "progressA", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxSolverConstraintDesc_Pod, progressA));
sg.add_field("uint16_t progressB", "progressB", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxSolverConstraintDesc_Pod, progressB));
sg.add_field("uint16_t constraintLengthOver16", "constraintLengthOver16", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxSolverConstraintDesc_Pod, constraintLengthOver16));
sg.add_field("uint8_t padding[10]", "padding", "[u8; 10]", sizeof(uint8_t[10]), unsafe_offsetof(physx_PxSolverConstraintDesc_Pod, padding));
sg.end_struct(sizeof(physx::PxSolverConstraintDesc));
}
};
physx_PxSolverConstraintDesc_Pod::dump_layout(sg);
struct physx_PxSolverConstraintPrepDescBase_Pod: public physx::PxSolverConstraintPrepDescBase {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSolverConstraintPrepDescBase_Pod", "PxSolverConstraintPrepDescBase");
sg.add_field("physx_PxConstraintInvMassScale_Pod invMassScales", "invMassScales", "PxConstraintInvMassScale", sizeof(physx::PxConstraintInvMassScale), unsafe_offsetof(physx_PxSolverConstraintPrepDescBase_Pod, invMassScales));
sg.add_field("physx_PxSolverConstraintDesc_Pod* desc", "desc", "*mut PxSolverConstraintDesc", sizeof(physx::PxSolverConstraintDesc*), unsafe_offsetof(physx_PxSolverConstraintPrepDescBase_Pod, desc));
sg.add_field("physx_PxSolverBody_Pod const* body0", "body0", "*const PxSolverBody", sizeof(physx::PxSolverBody const*), unsafe_offsetof(physx_PxSolverConstraintPrepDescBase_Pod, body0));
sg.add_field("physx_PxSolverBody_Pod const* body1", "body1", "*const PxSolverBody", sizeof(physx::PxSolverBody const*), unsafe_offsetof(physx_PxSolverConstraintPrepDescBase_Pod, body1));
sg.add_field("physx_PxSolverBodyData_Pod const* data0", "data0", "*const PxSolverBodyData", sizeof(physx::PxSolverBodyData const*), unsafe_offsetof(physx_PxSolverConstraintPrepDescBase_Pod, data0));
sg.add_field("physx_PxSolverBodyData_Pod const* data1", "data1", "*const PxSolverBodyData", sizeof(physx::PxSolverBodyData const*), unsafe_offsetof(physx_PxSolverConstraintPrepDescBase_Pod, data1));
sg.add_field("physx_PxTransform_Pod bodyFrame0", "bodyFrame0", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxSolverConstraintPrepDescBase_Pod, bodyFrame0));
sg.add_field("physx_PxTransform_Pod bodyFrame1", "bodyFrame1", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxSolverConstraintPrepDescBase_Pod, bodyFrame1));
sg.add_field("int32_t bodyState0", "bodyState0", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxSolverConstraintPrepDescBase_Pod, bodyState0));
sg.add_field("int32_t bodyState1", "bodyState1", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxSolverConstraintPrepDescBase_Pod, bodyState1));
sg.end_struct(sizeof(physx::PxSolverConstraintPrepDescBase));
}
};
physx_PxSolverConstraintPrepDescBase_Pod::dump_layout(sg);
struct physx_PxSolverConstraintPrepDesc_Pod: public physx::PxSolverConstraintPrepDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSolverConstraintPrepDesc_Pod", "PxSolverConstraintPrepDesc");
sg.add_field("physx_PxConstraintInvMassScale_Pod invMassScales", "invMassScales", "PxConstraintInvMassScale", sizeof(physx::PxConstraintInvMassScale), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, invMassScales));
sg.add_field("physx_PxSolverConstraintDesc_Pod* desc", "desc", "*mut PxSolverConstraintDesc", sizeof(physx::PxSolverConstraintDesc*), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, desc));
sg.add_field("physx_PxSolverBody_Pod const* body0", "body0", "*const PxSolverBody", sizeof(physx::PxSolverBody const*), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, body0));
sg.add_field("physx_PxSolverBody_Pod const* body1", "body1", "*const PxSolverBody", sizeof(physx::PxSolverBody const*), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, body1));
sg.add_field("physx_PxSolverBodyData_Pod const* data0", "data0", "*const PxSolverBodyData", sizeof(physx::PxSolverBodyData const*), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, data0));
sg.add_field("physx_PxSolverBodyData_Pod const* data1", "data1", "*const PxSolverBodyData", sizeof(physx::PxSolverBodyData const*), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, data1));
sg.add_field("physx_PxTransform_Pod bodyFrame0", "bodyFrame0", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, bodyFrame0));
sg.add_field("physx_PxTransform_Pod bodyFrame1", "bodyFrame1", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, bodyFrame1));
sg.add_field("int32_t bodyState0", "bodyState0", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, bodyState0));
sg.add_field("int32_t bodyState1", "bodyState1", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, bodyState1));
sg.add_field("physx_Px1DConstraint_Pod* rows", "rows", "*mut Px1DConstraint", sizeof(physx::Px1DConstraint*), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, rows));
sg.add_field("uint32_t numRows", "numRows", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, numRows));
sg.add_field("float linBreakForce", "linBreakForce", "f32", sizeof(float), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, linBreakForce));
sg.add_field("float angBreakForce", "angBreakForce", "f32", sizeof(float), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, angBreakForce));
sg.add_field("float minResponseThreshold", "minResponseThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, minResponseThreshold));
sg.add_field("void* writeback", "writeback", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, writeback));
sg.add_field("bool disablePreprocessing", "disablePreprocessing", "bool", sizeof(bool), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, disablePreprocessing));
sg.add_field("bool improvedSlerp", "improvedSlerp", "bool", sizeof(bool), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, improvedSlerp));
sg.add_field("bool driveLimitsAreForces", "driveLimitsAreForces", "bool", sizeof(bool), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, driveLimitsAreForces));
sg.add_field("bool extendedLimits", "extendedLimits", "bool", sizeof(bool), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, extendedLimits));
sg.add_field("bool disableConstraint", "disableConstraint", "bool", sizeof(bool), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, disableConstraint));
sg.add_field("physx_PxVec3Padded_Pod body0WorldOffset", "body0WorldOffset", "PxVec3Padded", sizeof(physx::PxVec3Padded), unsafe_offsetof(physx_PxSolverConstraintPrepDesc_Pod, body0WorldOffset));
sg.end_struct(sizeof(physx::PxSolverConstraintPrepDesc));
}
};
physx_PxSolverConstraintPrepDesc_Pod::dump_layout(sg);
struct physx_PxSolverContactDesc_Pod: public physx::PxSolverContactDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSolverContactDesc_Pod", "PxSolverContactDesc");
sg.add_field("physx_PxConstraintInvMassScale_Pod invMassScales", "invMassScales", "PxConstraintInvMassScale", sizeof(physx::PxConstraintInvMassScale), unsafe_offsetof(physx_PxSolverContactDesc_Pod, invMassScales));
sg.add_field("physx_PxSolverConstraintDesc_Pod* desc", "desc", "*mut PxSolverConstraintDesc", sizeof(physx::PxSolverConstraintDesc*), unsafe_offsetof(physx_PxSolverContactDesc_Pod, desc));
sg.add_field("physx_PxSolverBody_Pod const* body0", "body0", "*const PxSolverBody", sizeof(physx::PxSolverBody const*), unsafe_offsetof(physx_PxSolverContactDesc_Pod, body0));
sg.add_field("physx_PxSolverBody_Pod const* body1", "body1", "*const PxSolverBody", sizeof(physx::PxSolverBody const*), unsafe_offsetof(physx_PxSolverContactDesc_Pod, body1));
sg.add_field("physx_PxSolverBodyData_Pod const* data0", "data0", "*const PxSolverBodyData", sizeof(physx::PxSolverBodyData const*), unsafe_offsetof(physx_PxSolverContactDesc_Pod, data0));
sg.add_field("physx_PxSolverBodyData_Pod const* data1", "data1", "*const PxSolverBodyData", sizeof(physx::PxSolverBodyData const*), unsafe_offsetof(physx_PxSolverContactDesc_Pod, data1));
sg.add_field("physx_PxTransform_Pod bodyFrame0", "bodyFrame0", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxSolverContactDesc_Pod, bodyFrame0));
sg.add_field("physx_PxTransform_Pod bodyFrame1", "bodyFrame1", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxSolverContactDesc_Pod, bodyFrame1));
sg.add_field("int32_t bodyState0", "bodyState0", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxSolverContactDesc_Pod, bodyState0));
sg.add_field("int32_t bodyState1", "bodyState1", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxSolverContactDesc_Pod, bodyState1));
sg.add_field("void* shapeInteraction", "shapeInteraction", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxSolverContactDesc_Pod, shapeInteraction));
sg.add_field("physx_PxContactPoint_Pod* contacts", "contacts", "*mut PxContactPoint", sizeof(physx::PxContactPoint*), unsafe_offsetof(physx_PxSolverContactDesc_Pod, contacts));
sg.add_field("uint32_t numContacts", "numContacts", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSolverContactDesc_Pod, numContacts));
sg.add_field("bool hasMaxImpulse", "hasMaxImpulse", "bool", sizeof(bool), unsafe_offsetof(physx_PxSolverContactDesc_Pod, hasMaxImpulse));
sg.add_field("bool disableStrongFriction", "disableStrongFriction", "bool", sizeof(bool), unsafe_offsetof(physx_PxSolverContactDesc_Pod, disableStrongFriction));
sg.add_field("bool hasForceThresholds", "hasForceThresholds", "bool", sizeof(bool), unsafe_offsetof(physx_PxSolverContactDesc_Pod, hasForceThresholds));
sg.add_field("float restDistance", "restDistance", "f32", sizeof(float), unsafe_offsetof(physx_PxSolverContactDesc_Pod, restDistance));
sg.add_field("float maxCCDSeparation", "maxCCDSeparation", "f32", sizeof(float), unsafe_offsetof(physx_PxSolverContactDesc_Pod, maxCCDSeparation));
sg.add_field("uint8_t* frictionPtr", "frictionPtr", "*mut u8", sizeof(uint8_t*), unsafe_offsetof(physx_PxSolverContactDesc_Pod, frictionPtr));
sg.add_field("uint8_t frictionCount", "frictionCount", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxSolverContactDesc_Pod, frictionCount));
sg.add_field("float* contactForces", "contactForces", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxSolverContactDesc_Pod, contactForces));
sg.add_field("uint32_t startFrictionPatchIndex", "startFrictionPatchIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSolverContactDesc_Pod, startFrictionPatchIndex));
sg.add_field("uint32_t numFrictionPatches", "numFrictionPatches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSolverContactDesc_Pod, numFrictionPatches));
sg.add_field("uint32_t startContactPatchIndex", "startContactPatchIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSolverContactDesc_Pod, startContactPatchIndex));
sg.add_field("uint16_t numContactPatches", "numContactPatches", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxSolverContactDesc_Pod, numContactPatches));
sg.add_field("uint16_t axisConstraintCount", "axisConstraintCount", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxSolverContactDesc_Pod, axisConstraintCount));
sg.add_field("float offsetSlop", "offsetSlop", "f32", sizeof(float), unsafe_offsetof(physx_PxSolverContactDesc_Pod, offsetSlop));
sg.end_struct(sizeof(physx::PxSolverContactDesc));
}
};
physx_PxSolverContactDesc_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxConstraintAllocator_Pod {\n void* vtable_;\n};\n");
struct physx_PxArticulationLimit_Pod: public physx::PxArticulationLimit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationLimit_Pod", "PxArticulationLimit");
sg.add_field("float low", "low", "f32", sizeof(float), unsafe_offsetof(physx_PxArticulationLimit_Pod, low));
sg.add_field("float high", "high", "f32", sizeof(float), unsafe_offsetof(physx_PxArticulationLimit_Pod, high));
sg.end_struct(sizeof(physx::PxArticulationLimit));
}
};
physx_PxArticulationLimit_Pod::dump_layout(sg);
struct physx_PxArticulationDrive_Pod: public physx::PxArticulationDrive {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationDrive_Pod", "PxArticulationDrive");
sg.add_field("float stiffness", "stiffness", "f32", sizeof(float), unsafe_offsetof(physx_PxArticulationDrive_Pod, stiffness));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxArticulationDrive_Pod, damping));
sg.add_field("float maxForce", "maxForce", "f32", sizeof(float), unsafe_offsetof(physx_PxArticulationDrive_Pod, maxForce));
sg.add_field("int32_t driveType", "driveType", "PxArticulationDriveType", sizeof(physx::PxArticulationDriveType::Enum), unsafe_offsetof(physx_PxArticulationDrive_Pod, driveType));
sg.end_struct(sizeof(physx::PxArticulationDrive));
}
};
physx_PxArticulationDrive_Pod::dump_layout(sg);
struct physx_PxTGSSolverBodyVel_Pod: public physx::PxTGSSolverBodyVel {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTGSSolverBodyVel_Pod", "PxTGSSolverBodyVel");
sg.add_field("physx_PxVec3_Pod linearVelocity", "linearVelocity", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, linearVelocity));
sg.add_field("uint16_t nbStaticInteractions", "nbStaticInteractions", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, nbStaticInteractions));
sg.add_field("uint16_t maxDynamicPartition", "maxDynamicPartition", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, maxDynamicPartition));
sg.add_field("physx_PxVec3_Pod angularVelocity", "angularVelocity", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, angularVelocity));
sg.add_field("uint32_t partitionMask", "partitionMask", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, partitionMask));
sg.add_field("physx_PxVec3_Pod deltaAngDt", "deltaAngDt", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, deltaAngDt));
sg.add_field("float maxAngVel", "maxAngVel", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, maxAngVel));
sg.add_field("physx_PxVec3_Pod deltaLinDt", "deltaLinDt", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, deltaLinDt));
sg.add_field("uint16_t lockFlags", "lockFlags", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, lockFlags));
sg.add_field("bool isKinematic", "isKinematic", "bool", sizeof(bool), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, isKinematic));
sg.add_field("uint8_t pad", "pad", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxTGSSolverBodyVel_Pod, pad));
sg.end_struct(sizeof(physx::PxTGSSolverBodyVel));
}
};
physx_PxTGSSolverBodyVel_Pod::dump_layout(sg);
struct physx_PxTGSSolverBodyTxInertia_Pod: public physx::PxTGSSolverBodyTxInertia {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTGSSolverBodyTxInertia_Pod", "PxTGSSolverBodyTxInertia");
sg.add_field("physx_PxTransform_Pod deltaBody2World", "deltaBody2World", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxTGSSolverBodyTxInertia_Pod, deltaBody2World));
sg.add_field("physx_PxMat33_Pod sqrtInvInertia", "sqrtInvInertia", "PxMat33", sizeof(physx::PxMat33), unsafe_offsetof(physx_PxTGSSolverBodyTxInertia_Pod, sqrtInvInertia));
sg.end_struct(sizeof(physx::PxTGSSolverBodyTxInertia));
}
};
physx_PxTGSSolverBodyTxInertia_Pod::dump_layout(sg);
struct physx_PxTGSSolverBodyData_Pod: public physx::PxTGSSolverBodyData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTGSSolverBodyData_Pod", "PxTGSSolverBodyData");
sg.add_field("physx_PxVec3_Pod originalLinearVelocity", "originalLinearVelocity", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, originalLinearVelocity));
sg.add_field("float maxContactImpulse", "maxContactImpulse", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, maxContactImpulse));
sg.add_field("physx_PxVec3_Pod originalAngularVelocity", "originalAngularVelocity", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, originalAngularVelocity));
sg.add_field("float penBiasClamp", "penBiasClamp", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, penBiasClamp));
sg.add_field("float invMass", "invMass", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, invMass));
sg.add_field("uint32_t nodeIndex", "nodeIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, nodeIndex));
sg.add_field("float reportThreshold", "reportThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, reportThreshold));
sg.add_field("uint32_t pad", "pad", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxTGSSolverBodyData_Pod, pad));
sg.end_struct(sizeof(physx::PxTGSSolverBodyData));
}
};
physx_PxTGSSolverBodyData_Pod::dump_layout(sg);
struct physx_PxTGSSolverConstraintPrepDescBase_Pod: public physx::PxTGSSolverConstraintPrepDescBase {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTGSSolverConstraintPrepDescBase_Pod", "PxTGSSolverConstraintPrepDescBase");
sg.add_field("physx_PxConstraintInvMassScale_Pod invMassScales", "invMassScales", "PxConstraintInvMassScale", sizeof(physx::PxConstraintInvMassScale), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, invMassScales));
sg.add_field("physx_PxSolverConstraintDesc_Pod* desc", "desc", "*mut PxSolverConstraintDesc", sizeof(physx::PxSolverConstraintDesc*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, desc));
sg.add_field("physx_PxTGSSolverBodyVel_Pod const* body0", "body0", "*const PxTGSSolverBodyVel", sizeof(physx::PxTGSSolverBodyVel const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, body0));
sg.add_field("physx_PxTGSSolverBodyVel_Pod const* body1", "body1", "*const PxTGSSolverBodyVel", sizeof(physx::PxTGSSolverBodyVel const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, body1));
sg.add_field("physx_PxTGSSolverBodyTxInertia_Pod const* body0TxI", "body0TxI", "*const PxTGSSolverBodyTxInertia", sizeof(physx::PxTGSSolverBodyTxInertia const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, body0TxI));
sg.add_field("physx_PxTGSSolverBodyTxInertia_Pod const* body1TxI", "body1TxI", "*const PxTGSSolverBodyTxInertia", sizeof(physx::PxTGSSolverBodyTxInertia const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, body1TxI));
sg.add_field("physx_PxTGSSolverBodyData_Pod const* bodyData0", "bodyData0", "*const PxTGSSolverBodyData", sizeof(physx::PxTGSSolverBodyData const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, bodyData0));
sg.add_field("physx_PxTGSSolverBodyData_Pod const* bodyData1", "bodyData1", "*const PxTGSSolverBodyData", sizeof(physx::PxTGSSolverBodyData const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, bodyData1));
sg.add_field("physx_PxTransform_Pod bodyFrame0", "bodyFrame0", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, bodyFrame0));
sg.add_field("physx_PxTransform_Pod bodyFrame1", "bodyFrame1", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, bodyFrame1));
sg.add_field("int32_t bodyState0", "bodyState0", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, bodyState0));
sg.add_field("int32_t bodyState1", "bodyState1", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDescBase_Pod, bodyState1));
sg.end_struct(sizeof(physx::PxTGSSolverConstraintPrepDescBase));
}
};
physx_PxTGSSolverConstraintPrepDescBase_Pod::dump_layout(sg);
struct physx_PxTGSSolverConstraintPrepDesc_Pod: public physx::PxTGSSolverConstraintPrepDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTGSSolverConstraintPrepDesc_Pod", "PxTGSSolverConstraintPrepDesc");
sg.add_field("physx_PxConstraintInvMassScale_Pod invMassScales", "invMassScales", "PxConstraintInvMassScale", sizeof(physx::PxConstraintInvMassScale), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, invMassScales));
sg.add_field("physx_PxSolverConstraintDesc_Pod* desc", "desc", "*mut PxSolverConstraintDesc", sizeof(physx::PxSolverConstraintDesc*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, desc));
sg.add_field("physx_PxTGSSolverBodyVel_Pod const* body0", "body0", "*const PxTGSSolverBodyVel", sizeof(physx::PxTGSSolverBodyVel const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, body0));
sg.add_field("physx_PxTGSSolverBodyVel_Pod const* body1", "body1", "*const PxTGSSolverBodyVel", sizeof(physx::PxTGSSolverBodyVel const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, body1));
sg.add_field("physx_PxTGSSolverBodyTxInertia_Pod const* body0TxI", "body0TxI", "*const PxTGSSolverBodyTxInertia", sizeof(physx::PxTGSSolverBodyTxInertia const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, body0TxI));
sg.add_field("physx_PxTGSSolverBodyTxInertia_Pod const* body1TxI", "body1TxI", "*const PxTGSSolverBodyTxInertia", sizeof(physx::PxTGSSolverBodyTxInertia const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, body1TxI));
sg.add_field("physx_PxTGSSolverBodyData_Pod const* bodyData0", "bodyData0", "*const PxTGSSolverBodyData", sizeof(physx::PxTGSSolverBodyData const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, bodyData0));
sg.add_field("physx_PxTGSSolverBodyData_Pod const* bodyData1", "bodyData1", "*const PxTGSSolverBodyData", sizeof(physx::PxTGSSolverBodyData const*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, bodyData1));
sg.add_field("physx_PxTransform_Pod bodyFrame0", "bodyFrame0", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, bodyFrame0));
sg.add_field("physx_PxTransform_Pod bodyFrame1", "bodyFrame1", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, bodyFrame1));
sg.add_field("int32_t bodyState0", "bodyState0", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, bodyState0));
sg.add_field("int32_t bodyState1", "bodyState1", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, bodyState1));
sg.add_field("physx_Px1DConstraint_Pod* rows", "rows", "*mut Px1DConstraint", sizeof(physx::Px1DConstraint*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, rows));
sg.add_field("uint32_t numRows", "numRows", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, numRows));
sg.add_field("float linBreakForce", "linBreakForce", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, linBreakForce));
sg.add_field("float angBreakForce", "angBreakForce", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, angBreakForce));
sg.add_field("float minResponseThreshold", "minResponseThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, minResponseThreshold));
sg.add_field("void* writeback", "writeback", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, writeback));
sg.add_field("bool disablePreprocessing", "disablePreprocessing", "bool", sizeof(bool), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, disablePreprocessing));
sg.add_field("bool improvedSlerp", "improvedSlerp", "bool", sizeof(bool), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, improvedSlerp));
sg.add_field("bool driveLimitsAreForces", "driveLimitsAreForces", "bool", sizeof(bool), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, driveLimitsAreForces));
sg.add_field("bool extendedLimits", "extendedLimits", "bool", sizeof(bool), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, extendedLimits));
sg.add_field("bool disableConstraint", "disableConstraint", "bool", sizeof(bool), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, disableConstraint));
sg.add_field("physx_PxVec3Padded_Pod body0WorldOffset", "body0WorldOffset", "PxVec3Padded", sizeof(physx::PxVec3Padded), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, body0WorldOffset));
sg.add_field("physx_PxVec3Padded_Pod cA2w", "cA2w", "PxVec3Padded", sizeof(physx::PxVec3Padded), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, cA2w));
sg.add_field("physx_PxVec3Padded_Pod cB2w", "cB2w", "PxVec3Padded", sizeof(physx::PxVec3Padded), unsafe_offsetof(physx_PxTGSSolverConstraintPrepDesc_Pod, cB2w));
sg.end_struct(sizeof(physx::PxTGSSolverConstraintPrepDesc));
}
};
physx_PxTGSSolverConstraintPrepDesc_Pod::dump_layout(sg);
struct physx_PxTGSSolverContactDesc_Pod: public physx::PxTGSSolverContactDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTGSSolverContactDesc_Pod", "PxTGSSolverContactDesc");
sg.add_field("physx_PxConstraintInvMassScale_Pod invMassScales", "invMassScales", "PxConstraintInvMassScale", sizeof(physx::PxConstraintInvMassScale), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, invMassScales));
sg.add_field("physx_PxSolverConstraintDesc_Pod* desc", "desc", "*mut PxSolverConstraintDesc", sizeof(physx::PxSolverConstraintDesc*), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, desc));
sg.add_field("physx_PxTGSSolverBodyVel_Pod const* body0", "body0", "*const PxTGSSolverBodyVel", sizeof(physx::PxTGSSolverBodyVel const*), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, body0));
sg.add_field("physx_PxTGSSolverBodyVel_Pod const* body1", "body1", "*const PxTGSSolverBodyVel", sizeof(physx::PxTGSSolverBodyVel const*), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, body1));
sg.add_field("physx_PxTGSSolverBodyTxInertia_Pod const* body0TxI", "body0TxI", "*const PxTGSSolverBodyTxInertia", sizeof(physx::PxTGSSolverBodyTxInertia const*), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, body0TxI));
sg.add_field("physx_PxTGSSolverBodyTxInertia_Pod const* body1TxI", "body1TxI", "*const PxTGSSolverBodyTxInertia", sizeof(physx::PxTGSSolverBodyTxInertia const*), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, body1TxI));
sg.add_field("physx_PxTGSSolverBodyData_Pod const* bodyData0", "bodyData0", "*const PxTGSSolverBodyData", sizeof(physx::PxTGSSolverBodyData const*), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, bodyData0));
sg.add_field("physx_PxTGSSolverBodyData_Pod const* bodyData1", "bodyData1", "*const PxTGSSolverBodyData", sizeof(physx::PxTGSSolverBodyData const*), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, bodyData1));
sg.add_field("physx_PxTransform_Pod bodyFrame0", "bodyFrame0", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, bodyFrame0));
sg.add_field("physx_PxTransform_Pod bodyFrame1", "bodyFrame1", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, bodyFrame1));
sg.add_field("int32_t bodyState0", "bodyState0", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, bodyState0));
sg.add_field("int32_t bodyState1", "bodyState1", "BodyState", sizeof(physx::PxSolverConstraintPrepDescBase::BodyState), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, bodyState1));
sg.add_field("void* shapeInteraction", "shapeInteraction", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, shapeInteraction));
sg.add_field("physx_PxContactPoint_Pod* contacts", "contacts", "*mut PxContactPoint", sizeof(physx::PxContactPoint*), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, contacts));
sg.add_field("uint32_t numContacts", "numContacts", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, numContacts));
sg.add_field("bool hasMaxImpulse", "hasMaxImpulse", "bool", sizeof(bool), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, hasMaxImpulse));
sg.add_field("bool disableStrongFriction", "disableStrongFriction", "bool", sizeof(bool), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, disableStrongFriction));
sg.add_field("bool hasForceThresholds", "hasForceThresholds", "bool", sizeof(bool), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, hasForceThresholds));
sg.add_field("float restDistance", "restDistance", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, restDistance));
sg.add_field("float maxCCDSeparation", "maxCCDSeparation", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, maxCCDSeparation));
sg.add_field("uint8_t* frictionPtr", "frictionPtr", "*mut u8", sizeof(uint8_t*), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, frictionPtr));
sg.add_field("uint8_t frictionCount", "frictionCount", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, frictionCount));
sg.add_field("float* contactForces", "contactForces", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, contactForces));
sg.add_field("uint32_t startFrictionPatchIndex", "startFrictionPatchIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, startFrictionPatchIndex));
sg.add_field("uint32_t numFrictionPatches", "numFrictionPatches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, numFrictionPatches));
sg.add_field("uint32_t startContactPatchIndex", "startContactPatchIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, startContactPatchIndex));
sg.add_field("uint16_t numContactPatches", "numContactPatches", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, numContactPatches));
sg.add_field("uint16_t axisConstraintCount", "axisConstraintCount", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, axisConstraintCount));
sg.add_field("float maxImpulse", "maxImpulse", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, maxImpulse));
sg.add_field("float torsionalPatchRadius", "torsionalPatchRadius", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, torsionalPatchRadius));
sg.add_field("float minTorsionalPatchRadius", "minTorsionalPatchRadius", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, minTorsionalPatchRadius));
sg.add_field("float offsetSlop", "offsetSlop", "f32", sizeof(float), unsafe_offsetof(physx_PxTGSSolverContactDesc_Pod, offsetSlop));
sg.end_struct(sizeof(physx::PxTGSSolverContactDesc));
}
};
physx_PxTGSSolverContactDesc_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxArticulationSpatialTendon_Pod;\n");
sg.pass_thru("struct physx_PxArticulationFixedTendon_Pod;\n");
struct physx_PxArticulationTendonLimit_Pod: public physx::PxArticulationTendonLimit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationTendonLimit_Pod", "PxArticulationTendonLimit");
sg.add_field("float lowLimit", "lowLimit", "f32", sizeof(float), unsafe_offsetof(physx_PxArticulationTendonLimit_Pod, lowLimit));
sg.add_field("float highLimit", "highLimit", "f32", sizeof(float), unsafe_offsetof(physx_PxArticulationTendonLimit_Pod, highLimit));
sg.end_struct(sizeof(physx::PxArticulationTendonLimit));
}
};
physx_PxArticulationTendonLimit_Pod::dump_layout(sg);
struct physx_PxArticulationAttachment_Pod: public physx::PxArticulationAttachment {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationAttachment_Pod", "PxArticulationAttachment");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxArticulationAttachment_Pod, userData));
sg.end_struct(sizeof(physx::PxArticulationAttachment));
}
};
physx_PxArticulationAttachment_Pod::dump_layout(sg);
struct physx_PxArticulationTendonJoint_Pod: public physx::PxArticulationTendonJoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationTendonJoint_Pod", "PxArticulationTendonJoint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxArticulationTendonJoint_Pod, userData));
sg.end_struct(sizeof(physx::PxArticulationTendonJoint));
}
};
physx_PxArticulationTendonJoint_Pod::dump_layout(sg);
struct physx_PxArticulationTendon_Pod: public physx::PxArticulationTendon {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationTendon_Pod", "PxArticulationTendon");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxArticulationTendon_Pod, userData));
sg.end_struct(sizeof(physx::PxArticulationTendon));
}
};
physx_PxArticulationTendon_Pod::dump_layout(sg);
struct physx_PxArticulationSpatialTendon_Pod: public physx::PxArticulationSpatialTendon {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationSpatialTendon_Pod", "PxArticulationSpatialTendon");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxArticulationSpatialTendon_Pod, userData));
sg.end_struct(sizeof(physx::PxArticulationSpatialTendon));
}
};
physx_PxArticulationSpatialTendon_Pod::dump_layout(sg);
struct physx_PxArticulationFixedTendon_Pod: public physx::PxArticulationFixedTendon {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationFixedTendon_Pod", "PxArticulationFixedTendon");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxArticulationFixedTendon_Pod, userData));
sg.end_struct(sizeof(physx::PxArticulationFixedTendon));
}
};
physx_PxArticulationFixedTendon_Pod::dump_layout(sg);
struct physx_PxSpatialForce_Pod: public physx::PxSpatialForce {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSpatialForce_Pod", "PxSpatialForce");
sg.add_field("physx_PxVec3_Pod force", "force", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSpatialForce_Pod, force));
sg.add_field("float pad0", "pad0", "f32", sizeof(float), unsafe_offsetof(physx_PxSpatialForce_Pod, pad0));
sg.add_field("physx_PxVec3_Pod torque", "torque", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSpatialForce_Pod, torque));
sg.add_field("float pad1", "pad1", "f32", sizeof(float), unsafe_offsetof(physx_PxSpatialForce_Pod, pad1));
sg.end_struct(sizeof(physx::PxSpatialForce));
}
};
physx_PxSpatialForce_Pod::dump_layout(sg);
struct physx_PxSpatialVelocity_Pod: public physx::PxSpatialVelocity {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSpatialVelocity_Pod", "PxSpatialVelocity");
sg.add_field("physx_PxVec3_Pod linear", "linear", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSpatialVelocity_Pod, linear));
sg.add_field("float pad0", "pad0", "f32", sizeof(float), unsafe_offsetof(physx_PxSpatialVelocity_Pod, pad0));
sg.add_field("physx_PxVec3_Pod angular", "angular", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSpatialVelocity_Pod, angular));
sg.add_field("float pad1", "pad1", "f32", sizeof(float), unsafe_offsetof(physx_PxSpatialVelocity_Pod, pad1));
sg.end_struct(sizeof(physx::PxSpatialVelocity));
}
};
physx_PxSpatialVelocity_Pod::dump_layout(sg);
struct physx_PxArticulationRootLinkData_Pod: public physx::PxArticulationRootLinkData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationRootLinkData_Pod", "PxArticulationRootLinkData");
sg.add_field("physx_PxTransform_Pod transform", "transform", "PxTransform", sizeof(physx::PxTransform), unsafe_offsetof(physx_PxArticulationRootLinkData_Pod, transform));
sg.add_field("physx_PxVec3_Pod worldLinVel", "worldLinVel", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxArticulationRootLinkData_Pod, worldLinVel));
sg.add_field("physx_PxVec3_Pod worldAngVel", "worldAngVel", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxArticulationRootLinkData_Pod, worldAngVel));
sg.add_field("physx_PxVec3_Pod worldLinAccel", "worldLinAccel", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxArticulationRootLinkData_Pod, worldLinAccel));
sg.add_field("physx_PxVec3_Pod worldAngAccel", "worldAngAccel", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxArticulationRootLinkData_Pod, worldAngAccel));
sg.end_struct(sizeof(physx::PxArticulationRootLinkData));
}
};
physx_PxArticulationRootLinkData_Pod::dump_layout(sg);
struct physx_PxArticulationCache_Pod: public physx::PxArticulationCache {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationCache_Pod", "PxArticulationCache");
sg.add_field("physx_PxSpatialForce_Pod* externalForces", "externalForces", "*mut PxSpatialForce", sizeof(physx::PxSpatialForce*), unsafe_offsetof(physx_PxArticulationCache_Pod, externalForces));
sg.add_field("float* denseJacobian", "denseJacobian", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxArticulationCache_Pod, denseJacobian));
sg.add_field("float* massMatrix", "massMatrix", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxArticulationCache_Pod, massMatrix));
sg.add_field("float* jointVelocity", "jointVelocity", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxArticulationCache_Pod, jointVelocity));
sg.add_field("float* jointAcceleration", "jointAcceleration", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxArticulationCache_Pod, jointAcceleration));
sg.add_field("float* jointPosition", "jointPosition", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxArticulationCache_Pod, jointPosition));
sg.add_field("float* jointForce", "jointForce", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxArticulationCache_Pod, jointForce));
sg.add_field("float* jointSolverForces", "jointSolverForces", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxArticulationCache_Pod, jointSolverForces));
sg.add_field("physx_PxSpatialVelocity_Pod* linkVelocity", "linkVelocity", "*mut PxSpatialVelocity", sizeof(physx::PxSpatialVelocity*), unsafe_offsetof(physx_PxArticulationCache_Pod, linkVelocity));
sg.add_field("physx_PxSpatialVelocity_Pod* linkAcceleration", "linkAcceleration", "*mut PxSpatialVelocity", sizeof(physx::PxSpatialVelocity*), unsafe_offsetof(physx_PxArticulationCache_Pod, linkAcceleration));
sg.add_field("physx_PxArticulationRootLinkData_Pod* rootLinkData", "rootLinkData", "*mut PxArticulationRootLinkData", sizeof(physx::PxArticulationRootLinkData*), unsafe_offsetof(physx_PxArticulationCache_Pod, rootLinkData));
sg.add_field("physx_PxSpatialForce_Pod* sensorForces", "sensorForces", "*mut PxSpatialForce", sizeof(physx::PxSpatialForce*), unsafe_offsetof(physx_PxArticulationCache_Pod, sensorForces));
sg.add_field("float* coefficientMatrix", "coefficientMatrix", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxArticulationCache_Pod, coefficientMatrix));
sg.add_field("float* lambda", "lambda", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxArticulationCache_Pod, lambda));
sg.add_field("void* scratchMemory", "scratchMemory", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxArticulationCache_Pod, scratchMemory));
sg.add_field("void* scratchAllocator", "scratchAllocator", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxArticulationCache_Pod, scratchAllocator));
sg.add_field("uint32_t version", "version", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxArticulationCache_Pod, version));
sg.end_struct(sizeof(physx::PxArticulationCache));
}
};
physx_PxArticulationCache_Pod::dump_layout(sg);
struct physx_PxArticulationSensor_Pod: public physx::PxArticulationSensor {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationSensor_Pod", "PxArticulationSensor");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxArticulationSensor_Pod, userData));
sg.end_struct(sizeof(physx::PxArticulationSensor));
}
};
physx_PxArticulationSensor_Pod::dump_layout(sg);
struct physx_PxArticulationReducedCoordinate_Pod: public physx::PxArticulationReducedCoordinate {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationReducedCoordinate_Pod", "PxArticulationReducedCoordinate");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxArticulationReducedCoordinate_Pod, userData));
sg.end_struct(sizeof(physx::PxArticulationReducedCoordinate));
}
};
physx_PxArticulationReducedCoordinate_Pod::dump_layout(sg);
struct physx_PxArticulationJointReducedCoordinate_Pod: public physx::PxArticulationJointReducedCoordinate {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationJointReducedCoordinate_Pod", "PxArticulationJointReducedCoordinate");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxArticulationJointReducedCoordinate_Pod, userData));
sg.end_struct(sizeof(physx::PxArticulationJointReducedCoordinate));
}
};
physx_PxArticulationJointReducedCoordinate_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxFilterData_Pod;\n");
sg.pass_thru("struct physx_PxBaseMaterial_Pod;\n");
struct physx_PxShape_Pod: public physx::PxShape {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxShape_Pod", "PxShape");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxShape_Pod, userData));
sg.end_struct(sizeof(physx::PxShape));
}
};
physx_PxShape_Pod::dump_layout(sg);
struct physx_PxRigidActor_Pod: public physx::PxRigidActor {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRigidActor_Pod", "PxRigidActor");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxRigidActor_Pod, userData));
sg.end_struct(sizeof(physx::PxRigidActor));
}
};
physx_PxRigidActor_Pod::dump_layout(sg);
struct physx_PxNodeIndex_Pod: public physx::PxNodeIndex {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxNodeIndex_Pod", "PxNodeIndex");
sg.end_struct(sizeof(physx::PxNodeIndex));
}
};
physx_PxNodeIndex_Pod::dump_layout(sg);
struct physx_PxRigidBody_Pod: public physx::PxRigidBody {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRigidBody_Pod", "PxRigidBody");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxRigidBody_Pod, userData));
sg.end_struct(sizeof(physx::PxRigidBody));
}
};
physx_PxRigidBody_Pod::dump_layout(sg);
struct physx_PxArticulationLink_Pod: public physx::PxArticulationLink {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxArticulationLink_Pod", "PxArticulationLink");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxArticulationLink_Pod, userData));
sg.end_struct(sizeof(physx::PxArticulationLink));
}
};
physx_PxArticulationLink_Pod::dump_layout(sg);
struct physx_PxConeLimitedConstraint_Pod: public physx::PxConeLimitedConstraint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxConeLimitedConstraint_Pod", "PxConeLimitedConstraint");
sg.add_field("physx_PxVec3_Pod mAxis", "mAxis", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxConeLimitedConstraint_Pod, mAxis));
sg.add_field("float mAngle", "mAngle", "f32", sizeof(float), unsafe_offsetof(physx_PxConeLimitedConstraint_Pod, mAngle));
sg.add_field("float mLowLimit", "mLowLimit", "f32", sizeof(float), unsafe_offsetof(physx_PxConeLimitedConstraint_Pod, mLowLimit));
sg.add_field("float mHighLimit", "mHighLimit", "f32", sizeof(float), unsafe_offsetof(physx_PxConeLimitedConstraint_Pod, mHighLimit));
sg.end_struct(sizeof(physx::PxConeLimitedConstraint));
}
};
physx_PxConeLimitedConstraint_Pod::dump_layout(sg);
struct physx_PxConeLimitParams_Pod: public physx::PxConeLimitParams {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxConeLimitParams_Pod", "PxConeLimitParams");
sg.add_field("physx_PxVec4_Pod lowHighLimits", "lowHighLimits", "PxVec4", sizeof(physx::PxVec4), unsafe_offsetof(physx_PxConeLimitParams_Pod, lowHighLimits));
sg.add_field("physx_PxVec4_Pod axisAngle", "axisAngle", "PxVec4", sizeof(physx::PxVec4), unsafe_offsetof(physx_PxConeLimitParams_Pod, axisAngle));
sg.end_struct(sizeof(physx::PxConeLimitParams));
}
};
physx_PxConeLimitParams_Pod::dump_layout(sg);
struct physx_PxConstraintShaderTable_Pod: public physx::PxConstraintShaderTable {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxConstraintShaderTable_Pod", "PxConstraintShaderTable");
sg.add_field("void * solverPrep", "solverPrep", "*mut std::ffi::c_void", sizeof(void *), unsafe_offsetof(physx_PxConstraintShaderTable_Pod, solverPrep));
sg.add_field("void * visualize", "visualize", "*mut std::ffi::c_void", sizeof(void *), unsafe_offsetof(physx_PxConstraintShaderTable_Pod, visualize));
sg.add_field("int32_t flag", "flag", "PxConstraintFlag", sizeof(physx::PxConstraintFlag::Enum), unsafe_offsetof(physx_PxConstraintShaderTable_Pod, flag));
sg.end_struct(sizeof(physx::PxConstraintShaderTable));
}
};
physx_PxConstraintShaderTable_Pod::dump_layout(sg);
struct physx_PxConstraint_Pod: public physx::PxConstraint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxConstraint_Pod", "PxConstraint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxConstraint_Pod, userData));
sg.end_struct(sizeof(physx::PxConstraint));
}
};
physx_PxConstraint_Pod::dump_layout(sg);
struct physx_PxMassModificationProps_Pod: public physx::PxMassModificationProps {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxMassModificationProps_Pod", "PxMassModificationProps");
sg.add_field("float mInvMassScale0", "mInvMassScale0", "f32", sizeof(float), unsafe_offsetof(physx_PxMassModificationProps_Pod, mInvMassScale0));
sg.add_field("float mInvInertiaScale0", "mInvInertiaScale0", "f32", sizeof(float), unsafe_offsetof(physx_PxMassModificationProps_Pod, mInvInertiaScale0));
sg.add_field("float mInvMassScale1", "mInvMassScale1", "f32", sizeof(float), unsafe_offsetof(physx_PxMassModificationProps_Pod, mInvMassScale1));
sg.add_field("float mInvInertiaScale1", "mInvInertiaScale1", "f32", sizeof(float), unsafe_offsetof(physx_PxMassModificationProps_Pod, mInvInertiaScale1));
sg.end_struct(sizeof(physx::PxMassModificationProps));
}
};
physx_PxMassModificationProps_Pod::dump_layout(sg);
struct physx_PxContactPatch_Pod: public physx::PxContactPatch {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactPatch_Pod", "PxContactPatch");
sg.add_field("physx_PxMassModificationProps_Pod mMassModification", "mMassModification", "PxMassModificationProps", sizeof(physx::PxMassModificationProps), unsafe_offsetof(physx_PxContactPatch_Pod, mMassModification));
sg.add_field("physx_PxVec3_Pod normal", "normal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactPatch_Pod, normal));
sg.add_field("float restitution", "restitution", "f32", sizeof(float), unsafe_offsetof(physx_PxContactPatch_Pod, restitution));
sg.add_field("float dynamicFriction", "dynamicFriction", "f32", sizeof(float), unsafe_offsetof(physx_PxContactPatch_Pod, dynamicFriction));
sg.add_field("float staticFriction", "staticFriction", "f32", sizeof(float), unsafe_offsetof(physx_PxContactPatch_Pod, staticFriction));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxContactPatch_Pod, damping));
sg.add_field("uint16_t startContactIndex", "startContactIndex", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxContactPatch_Pod, startContactIndex));
sg.add_field("uint8_t nbContacts", "nbContacts", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxContactPatch_Pod, nbContacts));
sg.add_field("uint8_t materialFlags", "materialFlags", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxContactPatch_Pod, materialFlags));
sg.add_field("uint16_t internalFlags", "internalFlags", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxContactPatch_Pod, internalFlags));
sg.add_field("uint16_t materialIndex0", "materialIndex0", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxContactPatch_Pod, materialIndex0));
sg.add_field("uint16_t materialIndex1", "materialIndex1", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxContactPatch_Pod, materialIndex1));
sg.add_field("uint16_t pad[5]", "pad", "[u16; 5]", sizeof(uint16_t[5]), unsafe_offsetof(physx_PxContactPatch_Pod, pad));
sg.end_struct(sizeof(physx::PxContactPatch));
}
};
physx_PxContactPatch_Pod::dump_layout(sg);
struct physx_PxContact_Pod: public physx::PxContact {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContact_Pod", "PxContact");
sg.add_field("physx_PxVec3_Pod contact", "contact", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContact_Pod, contact));
sg.add_field("float separation", "separation", "f32", sizeof(float), unsafe_offsetof(physx_PxContact_Pod, separation));
sg.end_struct(sizeof(physx::PxContact));
}
};
physx_PxContact_Pod::dump_layout(sg);
struct physx_PxExtendedContact_Pod: public physx::PxExtendedContact {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxExtendedContact_Pod", "PxExtendedContact");
sg.add_field("physx_PxVec3_Pod contact", "contact", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxExtendedContact_Pod, contact));
sg.add_field("float separation", "separation", "f32", sizeof(float), unsafe_offsetof(physx_PxExtendedContact_Pod, separation));
sg.add_field("physx_PxVec3_Pod targetVelocity", "targetVelocity", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxExtendedContact_Pod, targetVelocity));
sg.add_field("float maxImpulse", "maxImpulse", "f32", sizeof(float), unsafe_offsetof(physx_PxExtendedContact_Pod, maxImpulse));
sg.end_struct(sizeof(physx::PxExtendedContact));
}
};
physx_PxExtendedContact_Pod::dump_layout(sg);
struct physx_PxModifiableContact_Pod: public physx::PxModifiableContact {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxModifiableContact_Pod", "PxModifiableContact");
sg.add_field("physx_PxVec3_Pod contact", "contact", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxModifiableContact_Pod, contact));
sg.add_field("float separation", "separation", "f32", sizeof(float), unsafe_offsetof(physx_PxModifiableContact_Pod, separation));
sg.add_field("physx_PxVec3_Pod targetVelocity", "targetVelocity", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxModifiableContact_Pod, targetVelocity));
sg.add_field("float maxImpulse", "maxImpulse", "f32", sizeof(float), unsafe_offsetof(physx_PxModifiableContact_Pod, maxImpulse));
sg.add_field("physx_PxVec3_Pod normal", "normal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxModifiableContact_Pod, normal));
sg.add_field("float restitution", "restitution", "f32", sizeof(float), unsafe_offsetof(physx_PxModifiableContact_Pod, restitution));
sg.add_field("uint32_t materialFlags", "materialFlags", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxModifiableContact_Pod, materialFlags));
sg.add_field("uint16_t materialIndex0", "materialIndex0", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxModifiableContact_Pod, materialIndex0));
sg.add_field("uint16_t materialIndex1", "materialIndex1", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxModifiableContact_Pod, materialIndex1));
sg.add_field("float staticFriction", "staticFriction", "f32", sizeof(float), unsafe_offsetof(physx_PxModifiableContact_Pod, staticFriction));
sg.add_field("float dynamicFriction", "dynamicFriction", "f32", sizeof(float), unsafe_offsetof(physx_PxModifiableContact_Pod, dynamicFriction));
sg.end_struct(sizeof(physx::PxModifiableContact));
}
};
physx_PxModifiableContact_Pod::dump_layout(sg);
struct physx_PxContactStreamIterator_Pod: public physx::PxContactStreamIterator {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactStreamIterator_Pod", "PxContactStreamIterator");
sg.add_field("physx_PxVec3_Pod zero", "zero", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactStreamIterator_Pod, zero));
sg.add_field("physx_PxContactPatch_Pod const* patch", "patch", "*const PxContactPatch", sizeof(physx::PxContactPatch const*), unsafe_offsetof(physx_PxContactStreamIterator_Pod, patch));
sg.add_field("physx_PxContact_Pod const* contact", "contact", "*const PxContact", sizeof(physx::PxContact const*), unsafe_offsetof(physx_PxContactStreamIterator_Pod, contact));
sg.add_field("uint32_t const* faceIndice", "faceIndice", "*const u32", sizeof(uint32_t const*), unsafe_offsetof(physx_PxContactStreamIterator_Pod, faceIndice));
sg.add_field("uint32_t totalPatches", "totalPatches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactStreamIterator_Pod, totalPatches));
sg.add_field("uint32_t totalContacts", "totalContacts", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactStreamIterator_Pod, totalContacts));
sg.add_field("uint32_t nextContactIndex", "nextContactIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactStreamIterator_Pod, nextContactIndex));
sg.add_field("uint32_t nextPatchIndex", "nextPatchIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactStreamIterator_Pod, nextPatchIndex));
sg.add_field("uint32_t contactPatchHeaderSize", "contactPatchHeaderSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactStreamIterator_Pod, contactPatchHeaderSize));
sg.add_field("uint32_t contactPointSize", "contactPointSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactStreamIterator_Pod, contactPointSize));
sg.add_field("int32_t mStreamFormat", "mStreamFormat", "StreamFormat", sizeof(physx::PxContactStreamIterator::StreamFormat), unsafe_offsetof(physx_PxContactStreamIterator_Pod, mStreamFormat));
sg.add_field("uint32_t forceNoResponse", "forceNoResponse", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactStreamIterator_Pod, forceNoResponse));
sg.add_field("bool pointStepped", "pointStepped", "bool", sizeof(bool), unsafe_offsetof(physx_PxContactStreamIterator_Pod, pointStepped));
sg.add_field("uint32_t hasFaceIndices", "hasFaceIndices", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactStreamIterator_Pod, hasFaceIndices));
sg.end_struct(sizeof(physx::PxContactStreamIterator));
}
};
physx_PxContactStreamIterator_Pod::dump_layout(sg);
struct physx_PxGpuContactPair_Pod: public physx::PxGpuContactPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGpuContactPair_Pod", "PxGpuContactPair");
sg.add_field("uint8_t* contactPatches", "contactPatches", "*mut u8", sizeof(uint8_t*), unsafe_offsetof(physx_PxGpuContactPair_Pod, contactPatches));
sg.add_field("uint8_t* contactPoints", "contactPoints", "*mut u8", sizeof(uint8_t*), unsafe_offsetof(physx_PxGpuContactPair_Pod, contactPoints));
sg.add_field("float* contactForces", "contactForces", "*mut f32", sizeof(float*), unsafe_offsetof(physx_PxGpuContactPair_Pod, contactForces));
sg.add_field("uint32_t transformCacheRef0", "transformCacheRef0", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxGpuContactPair_Pod, transformCacheRef0));
sg.add_field("uint32_t transformCacheRef1", "transformCacheRef1", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxGpuContactPair_Pod, transformCacheRef1));
sg.add_field("physx_PxNodeIndex_Pod nodeIndex0", "nodeIndex0", "PxNodeIndex", sizeof(physx::PxNodeIndex), unsafe_offsetof(physx_PxGpuContactPair_Pod, nodeIndex0));
sg.add_field("physx_PxNodeIndex_Pod nodeIndex1", "nodeIndex1", "PxNodeIndex", sizeof(physx::PxNodeIndex), unsafe_offsetof(physx_PxGpuContactPair_Pod, nodeIndex1));
sg.add_field("physx_PxActor_Pod* actor0", "actor0", "*mut PxActor", sizeof(physx::PxActor*), unsafe_offsetof(physx_PxGpuContactPair_Pod, actor0));
sg.add_field("physx_PxActor_Pod* actor1", "actor1", "*mut PxActor", sizeof(physx::PxActor*), unsafe_offsetof(physx_PxGpuContactPair_Pod, actor1));
sg.add_field("uint16_t nbContacts", "nbContacts", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxGpuContactPair_Pod, nbContacts));
sg.add_field("uint16_t nbPatches", "nbPatches", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxGpuContactPair_Pod, nbPatches));
sg.end_struct(sizeof(physx::PxGpuContactPair));
}
};
physx_PxGpuContactPair_Pod::dump_layout(sg);
struct physx_PxContactSet_Pod: public physx::PxContactSet {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactSet_Pod", "PxContactSet");
sg.end_struct(sizeof(physx::PxContactSet));
}
};
physx_PxContactSet_Pod::dump_layout(sg);
struct physx_PxContactModifyPair_Pod: public physx::PxContactModifyPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactModifyPair_Pod", "PxContactModifyPair");
sg.add_field("physx_PxRigidActor_Pod const* actor[2]", "actor", "[*const PxRigidActor; 2]", sizeof(physx::PxRigidActor const*[2]), unsafe_offsetof(physx_PxContactModifyPair_Pod, actor));
sg.add_field("physx_PxShape_Pod const* shape[2]", "shape", "[*const PxShape; 2]", sizeof(physx::PxShape const*[2]), unsafe_offsetof(physx_PxContactModifyPair_Pod, shape));
sg.add_field("physx_PxTransform_Pod transform[2]", "transform", "[PxTransform; 2]", sizeof(physx::PxTransform[2]), unsafe_offsetof(physx_PxContactModifyPair_Pod, transform));
sg.add_field("physx_PxContactSet_Pod contacts", "contacts", "PxContactSet", sizeof(physx::PxContactSet), unsafe_offsetof(physx_PxContactModifyPair_Pod, contacts));
sg.end_struct(sizeof(physx::PxContactModifyPair));
}
};
physx_PxContactModifyPair_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxContactModifyCallback_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxCCDContactModifyCallback_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxDeletionListener_Pod {\n void* vtable_;\n};\n");
struct physx_PxBaseMaterial_Pod: public physx::PxBaseMaterial {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBaseMaterial_Pod", "PxBaseMaterial");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxBaseMaterial_Pod, userData));
sg.end_struct(sizeof(physx::PxBaseMaterial));
}
};
physx_PxBaseMaterial_Pod::dump_layout(sg);
struct physx_PxFEMMaterial_Pod: public physx::PxFEMMaterial {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxFEMMaterial_Pod", "PxFEMMaterial");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxFEMMaterial_Pod, userData));
sg.end_struct(sizeof(physx::PxFEMMaterial));
}
};
physx_PxFEMMaterial_Pod::dump_layout(sg);
struct physx_PxFilterData_Pod: public physx::PxFilterData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxFilterData_Pod", "PxFilterData");
sg.add_field("uint32_t word0", "word0", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxFilterData_Pod, word0));
sg.add_field("uint32_t word1", "word1", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxFilterData_Pod, word1));
sg.add_field("uint32_t word2", "word2", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxFilterData_Pod, word2));
sg.add_field("uint32_t word3", "word3", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxFilterData_Pod, word3));
sg.end_struct(sizeof(physx::PxFilterData));
}
};
physx_PxFilterData_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxSimulationFilterCallback_Pod {\n void* vtable_;\n};\n");
struct physx_PxParticleRigidFilterPair_Pod: public physx::PxParticleRigidFilterPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxParticleRigidFilterPair_Pod", "PxParticleRigidFilterPair");
sg.add_field("uint64_t mID0", "mID0", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxParticleRigidFilterPair_Pod, mID0));
sg.add_field("uint64_t mID1", "mID1", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxParticleRigidFilterPair_Pod, mID1));
sg.end_struct(sizeof(physx::PxParticleRigidFilterPair));
}
};
physx_PxParticleRigidFilterPair_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxLockedData_Pod {\n void* vtable_;\n};\n");
struct physx_PxMaterial_Pod: public physx::PxMaterial {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxMaterial_Pod", "PxMaterial");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxMaterial_Pod, userData));
sg.end_struct(sizeof(physx::PxMaterial));
}
};
physx_PxMaterial_Pod::dump_layout(sg);
struct physx_PxGpuParticleBufferIndexPair_Pod: public physx::PxGpuParticleBufferIndexPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGpuParticleBufferIndexPair_Pod", "PxGpuParticleBufferIndexPair");
sg.add_field("uint32_t systemIndex", "systemIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxGpuParticleBufferIndexPair_Pod, systemIndex));
sg.add_field("uint32_t bufferIndex", "bufferIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxGpuParticleBufferIndexPair_Pod, bufferIndex));
sg.end_struct(sizeof(physx::PxGpuParticleBufferIndexPair));
}
};
physx_PxGpuParticleBufferIndexPair_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxCudaContextManager_Pod;\n");
sg.pass_thru("struct physx_PxParticleRigidAttachment_Pod;\n");
struct physx_PxParticleVolume_Pod: public physx::PxParticleVolume {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxParticleVolume_Pod", "PxParticleVolume");
sg.add_field("physx_PxBounds3_Pod bound", "bound", "PxBounds3", sizeof(physx::PxBounds3), unsafe_offsetof(physx_PxParticleVolume_Pod, bound));
sg.add_field("uint32_t particleIndicesOffset", "particleIndicesOffset", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxParticleVolume_Pod, particleIndicesOffset));
sg.add_field("uint32_t numParticles", "numParticles", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxParticleVolume_Pod, numParticles));
sg.end_struct(sizeof(physx::PxParticleVolume));
}
};
physx_PxParticleVolume_Pod::dump_layout(sg);
struct physx_PxDiffuseParticleParams_Pod: public physx::PxDiffuseParticleParams {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDiffuseParticleParams_Pod", "PxDiffuseParticleParams");
sg.add_field("float threshold", "threshold", "f32", sizeof(float), unsafe_offsetof(physx_PxDiffuseParticleParams_Pod, threshold));
sg.add_field("float lifetime", "lifetime", "f32", sizeof(float), unsafe_offsetof(physx_PxDiffuseParticleParams_Pod, lifetime));
sg.add_field("float airDrag", "airDrag", "f32", sizeof(float), unsafe_offsetof(physx_PxDiffuseParticleParams_Pod, airDrag));
sg.add_field("float bubbleDrag", "bubbleDrag", "f32", sizeof(float), unsafe_offsetof(physx_PxDiffuseParticleParams_Pod, bubbleDrag));
sg.add_field("float buoyancy", "buoyancy", "f32", sizeof(float), unsafe_offsetof(physx_PxDiffuseParticleParams_Pod, buoyancy));
sg.add_field("float kineticEnergyWeight", "kineticEnergyWeight", "f32", sizeof(float), unsafe_offsetof(physx_PxDiffuseParticleParams_Pod, kineticEnergyWeight));
sg.add_field("float pressureWeight", "pressureWeight", "f32", sizeof(float), unsafe_offsetof(physx_PxDiffuseParticleParams_Pod, pressureWeight));
sg.add_field("float divergenceWeight", "divergenceWeight", "f32", sizeof(float), unsafe_offsetof(physx_PxDiffuseParticleParams_Pod, divergenceWeight));
sg.add_field("float collisionDecay", "collisionDecay", "f32", sizeof(float), unsafe_offsetof(physx_PxDiffuseParticleParams_Pod, collisionDecay));
sg.add_field("bool useAccurateVelocity", "useAccurateVelocity", "bool", sizeof(bool), unsafe_offsetof(physx_PxDiffuseParticleParams_Pod, useAccurateVelocity));
sg.end_struct(sizeof(physx::PxDiffuseParticleParams));
}
};
physx_PxDiffuseParticleParams_Pod::dump_layout(sg);
struct physx_PxParticleSpring_Pod: public physx::PxParticleSpring {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxParticleSpring_Pod", "PxParticleSpring");
sg.add_field("uint32_t ind0", "ind0", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxParticleSpring_Pod, ind0));
sg.add_field("uint32_t ind1", "ind1", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxParticleSpring_Pod, ind1));
sg.add_field("float length", "length", "f32", sizeof(float), unsafe_offsetof(physx_PxParticleSpring_Pod, length));
sg.add_field("float stiffness", "stiffness", "f32", sizeof(float), unsafe_offsetof(physx_PxParticleSpring_Pod, stiffness));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxParticleSpring_Pod, damping));
sg.add_field("float pad", "pad", "f32", sizeof(float), unsafe_offsetof(physx_PxParticleSpring_Pod, pad));
sg.end_struct(sizeof(physx::PxParticleSpring));
}
};
physx_PxParticleSpring_Pod::dump_layout(sg);
struct physx_PxParticleMaterial_Pod: public physx::PxParticleMaterial {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxParticleMaterial_Pod", "PxParticleMaterial");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxParticleMaterial_Pod, userData));
sg.end_struct(sizeof(physx::PxParticleMaterial));
}
};
physx_PxParticleMaterial_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxSceneDesc_Pod;\n");
sg.pass_thru("struct physx_PxPvd_Pod;\n");
sg.pass_thru("struct physx_PxOmniPvd_Pod;\n");
sg.pass_thru("struct physx_PxPhysics_Pod {\n void* vtable_;\n};\n");
struct physx_PxActorShape_Pod: public physx::PxActorShape {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxActorShape_Pod", "PxActorShape");
sg.add_field("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor", sizeof(physx::PxRigidActor*), unsafe_offsetof(physx_PxActorShape_Pod, actor));
sg.add_field("physx_PxShape_Pod* shape", "shape", "*mut PxShape", sizeof(physx::PxShape*), unsafe_offsetof(physx_PxActorShape_Pod, shape));
sg.end_struct(sizeof(physx::PxActorShape));
}
};
physx_PxActorShape_Pod::dump_layout(sg);
struct physx_PxRaycastHit_Pod: public physx::PxRaycastHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRaycastHit_Pod", "PxRaycastHit");
sg.add_field("uint32_t faceIndex", "faceIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxRaycastHit_Pod, faceIndex));
sg.add_field("uint16_t flags", "flags", "PxHitFlags", sizeof(physx::PxHitFlags), unsafe_offsetof(physx_PxRaycastHit_Pod, flags));
sg.add_field("physx_PxVec3_Pod position", "position", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxRaycastHit_Pod, position));
sg.add_field("physx_PxVec3_Pod normal", "normal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxRaycastHit_Pod, normal));
sg.add_field("float distance", "distance", "f32", sizeof(float), unsafe_offsetof(physx_PxRaycastHit_Pod, distance));
sg.add_field("float u", "u", "f32", sizeof(float), unsafe_offsetof(physx_PxRaycastHit_Pod, u));
sg.add_field("float v", "v", "f32", sizeof(float), unsafe_offsetof(physx_PxRaycastHit_Pod, v));
sg.add_field("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor", sizeof(physx::PxRigidActor*), unsafe_offsetof(physx_PxRaycastHit_Pod, actor));
sg.add_field("physx_PxShape_Pod* shape", "shape", "*mut PxShape", sizeof(physx::PxShape*), unsafe_offsetof(physx_PxRaycastHit_Pod, shape));
sg.end_struct(sizeof(physx::PxRaycastHit));
}
};
physx_PxRaycastHit_Pod::dump_layout(sg);
struct physx_PxOverlapHit_Pod: public physx::PxOverlapHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxOverlapHit_Pod", "PxOverlapHit");
sg.add_field("uint32_t faceIndex", "faceIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxOverlapHit_Pod, faceIndex));
sg.add_field("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor", sizeof(physx::PxRigidActor*), unsafe_offsetof(physx_PxOverlapHit_Pod, actor));
sg.add_field("physx_PxShape_Pod* shape", "shape", "*mut PxShape", sizeof(physx::PxShape*), unsafe_offsetof(physx_PxOverlapHit_Pod, shape));
sg.end_struct(sizeof(physx::PxOverlapHit));
}
};
physx_PxOverlapHit_Pod::dump_layout(sg);
struct physx_PxSweepHit_Pod: public physx::PxSweepHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSweepHit_Pod", "PxSweepHit");
sg.add_field("uint32_t faceIndex", "faceIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSweepHit_Pod, faceIndex));
sg.add_field("uint16_t flags", "flags", "PxHitFlags", sizeof(physx::PxHitFlags), unsafe_offsetof(physx_PxSweepHit_Pod, flags));
sg.add_field("physx_PxVec3_Pod position", "position", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSweepHit_Pod, position));
sg.add_field("physx_PxVec3_Pod normal", "normal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSweepHit_Pod, normal));
sg.add_field("float distance", "distance", "f32", sizeof(float), unsafe_offsetof(physx_PxSweepHit_Pod, distance));
sg.add_field("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor", sizeof(physx::PxRigidActor*), unsafe_offsetof(physx_PxSweepHit_Pod, actor));
sg.add_field("physx_PxShape_Pod* shape", "shape", "*mut PxShape", sizeof(physx::PxShape*), unsafe_offsetof(physx_PxSweepHit_Pod, shape));
sg.end_struct(sizeof(physx::PxSweepHit));
}
};
physx_PxSweepHit_Pod::dump_layout(sg);
struct physx_PxRaycastCallback_Pod: public physx::PxRaycastCallback {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRaycastCallback_Pod", "PxRaycastCallback");
sg.add_field("physx_PxRaycastHit_Pod block", "block", "PxRaycastHit", sizeof(physx::PxRaycastHit), unsafe_offsetof(physx_PxRaycastCallback_Pod, block));
sg.add_field("bool hasBlock", "hasBlock", "bool", sizeof(bool), unsafe_offsetof(physx_PxRaycastCallback_Pod, hasBlock));
sg.add_field("physx_PxRaycastHit_Pod* touches", "touches", "*mut PxRaycastHit", sizeof(physx::PxRaycastHit*), unsafe_offsetof(physx_PxRaycastCallback_Pod, touches));
sg.add_field("uint32_t maxNbTouches", "maxNbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxRaycastCallback_Pod, maxNbTouches));
sg.add_field("uint32_t nbTouches", "nbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxRaycastCallback_Pod, nbTouches));
sg.end_struct(sizeof(physx::PxRaycastCallback));
}
};
physx_PxRaycastCallback_Pod::dump_layout(sg);
struct physx_PxOverlapCallback_Pod: public physx::PxOverlapCallback {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxOverlapCallback_Pod", "PxOverlapCallback");
sg.add_field("physx_PxOverlapHit_Pod block", "block", "PxOverlapHit", sizeof(physx::PxOverlapHit), unsafe_offsetof(physx_PxOverlapCallback_Pod, block));
sg.add_field("bool hasBlock", "hasBlock", "bool", sizeof(bool), unsafe_offsetof(physx_PxOverlapCallback_Pod, hasBlock));
sg.add_field("physx_PxOverlapHit_Pod* touches", "touches", "*mut PxOverlapHit", sizeof(physx::PxOverlapHit*), unsafe_offsetof(physx_PxOverlapCallback_Pod, touches));
sg.add_field("uint32_t maxNbTouches", "maxNbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxOverlapCallback_Pod, maxNbTouches));
sg.add_field("uint32_t nbTouches", "nbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxOverlapCallback_Pod, nbTouches));
sg.end_struct(sizeof(physx::PxOverlapCallback));
}
};
physx_PxOverlapCallback_Pod::dump_layout(sg);
struct physx_PxSweepCallback_Pod: public physx::PxSweepCallback {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSweepCallback_Pod", "PxSweepCallback");
sg.add_field("physx_PxSweepHit_Pod block", "block", "PxSweepHit", sizeof(physx::PxSweepHit), unsafe_offsetof(physx_PxSweepCallback_Pod, block));
sg.add_field("bool hasBlock", "hasBlock", "bool", sizeof(bool), unsafe_offsetof(physx_PxSweepCallback_Pod, hasBlock));
sg.add_field("physx_PxSweepHit_Pod* touches", "touches", "*mut PxSweepHit", sizeof(physx::PxSweepHit*), unsafe_offsetof(physx_PxSweepCallback_Pod, touches));
sg.add_field("uint32_t maxNbTouches", "maxNbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSweepCallback_Pod, maxNbTouches));
sg.add_field("uint32_t nbTouches", "nbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSweepCallback_Pod, nbTouches));
sg.end_struct(sizeof(physx::PxSweepCallback));
}
};
physx_PxSweepCallback_Pod::dump_layout(sg);
struct physx_PxRaycastBuffer_Pod: public physx::PxRaycastBuffer {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRaycastBuffer_Pod", "PxRaycastBuffer");
sg.add_field("physx_PxRaycastHit_Pod block", "block", "PxRaycastHit", sizeof(physx::PxRaycastHit), unsafe_offsetof(physx_PxRaycastBuffer_Pod, block));
sg.add_field("bool hasBlock", "hasBlock", "bool", sizeof(bool), unsafe_offsetof(physx_PxRaycastBuffer_Pod, hasBlock));
sg.add_field("physx_PxRaycastHit_Pod* touches", "touches", "*mut PxRaycastHit", sizeof(physx::PxRaycastHit*), unsafe_offsetof(physx_PxRaycastBuffer_Pod, touches));
sg.add_field("uint32_t maxNbTouches", "maxNbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxRaycastBuffer_Pod, maxNbTouches));
sg.add_field("uint32_t nbTouches", "nbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxRaycastBuffer_Pod, nbTouches));
sg.end_struct(sizeof(physx::PxRaycastBuffer));
}
};
physx_PxRaycastBuffer_Pod::dump_layout(sg);
struct physx_PxOverlapBuffer_Pod: public physx::PxOverlapBuffer {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxOverlapBuffer_Pod", "PxOverlapBuffer");
sg.add_field("physx_PxOverlapHit_Pod block", "block", "PxOverlapHit", sizeof(physx::PxOverlapHit), unsafe_offsetof(physx_PxOverlapBuffer_Pod, block));
sg.add_field("bool hasBlock", "hasBlock", "bool", sizeof(bool), unsafe_offsetof(physx_PxOverlapBuffer_Pod, hasBlock));
sg.add_field("physx_PxOverlapHit_Pod* touches", "touches", "*mut PxOverlapHit", sizeof(physx::PxOverlapHit*), unsafe_offsetof(physx_PxOverlapBuffer_Pod, touches));
sg.add_field("uint32_t maxNbTouches", "maxNbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxOverlapBuffer_Pod, maxNbTouches));
sg.add_field("uint32_t nbTouches", "nbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxOverlapBuffer_Pod, nbTouches));
sg.end_struct(sizeof(physx::PxOverlapBuffer));
}
};
physx_PxOverlapBuffer_Pod::dump_layout(sg);
struct physx_PxSweepBuffer_Pod: public physx::PxSweepBuffer {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSweepBuffer_Pod", "PxSweepBuffer");
sg.add_field("physx_PxSweepHit_Pod block", "block", "PxSweepHit", sizeof(physx::PxSweepHit), unsafe_offsetof(physx_PxSweepBuffer_Pod, block));
sg.add_field("bool hasBlock", "hasBlock", "bool", sizeof(bool), unsafe_offsetof(physx_PxSweepBuffer_Pod, hasBlock));
sg.add_field("physx_PxSweepHit_Pod* touches", "touches", "*mut PxSweepHit", sizeof(physx::PxSweepHit*), unsafe_offsetof(physx_PxSweepBuffer_Pod, touches));
sg.add_field("uint32_t maxNbTouches", "maxNbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSweepBuffer_Pod, maxNbTouches));
sg.add_field("uint32_t nbTouches", "nbTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSweepBuffer_Pod, nbTouches));
sg.end_struct(sizeof(physx::PxSweepBuffer));
}
};
physx_PxSweepBuffer_Pod::dump_layout(sg);
struct physx_PxQueryCache_Pod: public physx::PxQueryCache {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxQueryCache_Pod", "PxQueryCache");
sg.add_field("physx_PxShape_Pod* shape", "shape", "*mut PxShape", sizeof(physx::PxShape*), unsafe_offsetof(physx_PxQueryCache_Pod, shape));
sg.add_field("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor", sizeof(physx::PxRigidActor*), unsafe_offsetof(physx_PxQueryCache_Pod, actor));
sg.add_field("uint32_t faceIndex", "faceIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxQueryCache_Pod, faceIndex));
sg.end_struct(sizeof(physx::PxQueryCache));
}
};
physx_PxQueryCache_Pod::dump_layout(sg);
struct physx_PxQueryFilterData_Pod: public physx::PxQueryFilterData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxQueryFilterData_Pod", "PxQueryFilterData");
sg.add_field("physx_PxFilterData_Pod data", "data", "PxFilterData", sizeof(physx::PxFilterData), unsafe_offsetof(physx_PxQueryFilterData_Pod, data));
sg.add_field("uint16_t flags", "flags", "PxQueryFlags", sizeof(physx::PxQueryFlags), unsafe_offsetof(physx_PxQueryFilterData_Pod, flags));
sg.end_struct(sizeof(physx::PxQueryFilterData));
}
};
physx_PxQueryFilterData_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxQueryFilterCallback_Pod {\n void* vtable_;\n};\n");
struct physx_PxRigidDynamic_Pod: public physx::PxRigidDynamic {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRigidDynamic_Pod", "PxRigidDynamic");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxRigidDynamic_Pod, userData));
sg.end_struct(sizeof(physx::PxRigidDynamic));
}
};
physx_PxRigidDynamic_Pod::dump_layout(sg);
struct physx_PxRigidStatic_Pod: public physx::PxRigidStatic {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRigidStatic_Pod", "PxRigidStatic");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxRigidStatic_Pod, userData));
sg.end_struct(sizeof(physx::PxRigidStatic));
}
};
physx_PxRigidStatic_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxSceneQuerySystem_Pod;\n");
struct physx_PxSceneQueryDesc_Pod: public physx::PxSceneQueryDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSceneQueryDesc_Pod", "PxSceneQueryDesc");
sg.add_field("int32_t staticStructure", "staticStructure", "PxPruningStructureType", sizeof(physx::PxPruningStructureType::Enum), unsafe_offsetof(physx_PxSceneQueryDesc_Pod, staticStructure));
sg.add_field("int32_t dynamicStructure", "dynamicStructure", "PxPruningStructureType", sizeof(physx::PxPruningStructureType::Enum), unsafe_offsetof(physx_PxSceneQueryDesc_Pod, dynamicStructure));
sg.add_field("uint32_t dynamicTreeRebuildRateHint", "dynamicTreeRebuildRateHint", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneQueryDesc_Pod, dynamicTreeRebuildRateHint));
sg.add_field("int32_t dynamicTreeSecondaryPruner", "dynamicTreeSecondaryPruner", "PxDynamicTreeSecondaryPruner", sizeof(physx::PxDynamicTreeSecondaryPruner::Enum), unsafe_offsetof(physx_PxSceneQueryDesc_Pod, dynamicTreeSecondaryPruner));
sg.add_field("int32_t staticBVHBuildStrategy", "staticBVHBuildStrategy", "PxBVHBuildStrategy", sizeof(physx::PxBVHBuildStrategy::Enum), unsafe_offsetof(physx_PxSceneQueryDesc_Pod, staticBVHBuildStrategy));
sg.add_field("int32_t dynamicBVHBuildStrategy", "dynamicBVHBuildStrategy", "PxBVHBuildStrategy", sizeof(physx::PxBVHBuildStrategy::Enum), unsafe_offsetof(physx_PxSceneQueryDesc_Pod, dynamicBVHBuildStrategy));
sg.add_field("uint32_t staticNbObjectsPerNode", "staticNbObjectsPerNode", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneQueryDesc_Pod, staticNbObjectsPerNode));
sg.add_field("uint32_t dynamicNbObjectsPerNode", "dynamicNbObjectsPerNode", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneQueryDesc_Pod, dynamicNbObjectsPerNode));
sg.add_field("int32_t sceneQueryUpdateMode", "sceneQueryUpdateMode", "PxSceneQueryUpdateMode", sizeof(physx::PxSceneQueryUpdateMode::Enum), unsafe_offsetof(physx_PxSceneQueryDesc_Pod, sceneQueryUpdateMode));
sg.end_struct(sizeof(physx::PxSceneQueryDesc));
}
};
physx_PxSceneQueryDesc_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxSceneQuerySystemBase_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxSceneSQSystem_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxSceneQuerySystem_Pod {\n void* vtable_;\n};\n");
struct physx_PxBroadPhaseRegion_Pod: public physx::PxBroadPhaseRegion {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBroadPhaseRegion_Pod", "PxBroadPhaseRegion");
sg.add_field("physx_PxBounds3_Pod mBounds", "mBounds", "PxBounds3", sizeof(physx::PxBounds3), unsafe_offsetof(physx_PxBroadPhaseRegion_Pod, mBounds));
sg.add_field("void* mUserData", "mUserData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxBroadPhaseRegion_Pod, mUserData));
sg.end_struct(sizeof(physx::PxBroadPhaseRegion));
}
};
physx_PxBroadPhaseRegion_Pod::dump_layout(sg);
struct physx_PxBroadPhaseRegionInfo_Pod: public physx::PxBroadPhaseRegionInfo {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBroadPhaseRegionInfo_Pod", "PxBroadPhaseRegionInfo");
sg.add_field("physx_PxBroadPhaseRegion_Pod mRegion", "mRegion", "PxBroadPhaseRegion", sizeof(physx::PxBroadPhaseRegion), unsafe_offsetof(physx_PxBroadPhaseRegionInfo_Pod, mRegion));
sg.add_field("uint32_t mNbStaticObjects", "mNbStaticObjects", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhaseRegionInfo_Pod, mNbStaticObjects));
sg.add_field("uint32_t mNbDynamicObjects", "mNbDynamicObjects", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhaseRegionInfo_Pod, mNbDynamicObjects));
sg.add_field("bool mActive", "mActive", "bool", sizeof(bool), unsafe_offsetof(physx_PxBroadPhaseRegionInfo_Pod, mActive));
sg.add_field("bool mOverlap", "mOverlap", "bool", sizeof(bool), unsafe_offsetof(physx_PxBroadPhaseRegionInfo_Pod, mOverlap));
sg.end_struct(sizeof(physx::PxBroadPhaseRegionInfo));
}
};
physx_PxBroadPhaseRegionInfo_Pod::dump_layout(sg);
struct physx_PxBroadPhaseCaps_Pod: public physx::PxBroadPhaseCaps {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBroadPhaseCaps_Pod", "PxBroadPhaseCaps");
sg.add_field("uint32_t mMaxNbRegions", "mMaxNbRegions", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhaseCaps_Pod, mMaxNbRegions));
sg.end_struct(sizeof(physx::PxBroadPhaseCaps));
}
};
physx_PxBroadPhaseCaps_Pod::dump_layout(sg);
struct physx_PxBroadPhaseDesc_Pod: public physx::PxBroadPhaseDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBroadPhaseDesc_Pod", "PxBroadPhaseDesc");
sg.add_field("int32_t mType", "mType", "PxBroadPhaseType", sizeof(physx::PxBroadPhaseType::Enum), unsafe_offsetof(physx_PxBroadPhaseDesc_Pod, mType));
sg.add_field("uint64_t mContextID", "mContextID", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxBroadPhaseDesc_Pod, mContextID));
sg.add_field("uint32_t mFoundLostPairsCapacity", "mFoundLostPairsCapacity", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhaseDesc_Pod, mFoundLostPairsCapacity));
sg.add_field("bool mDiscardStaticVsKinematic", "mDiscardStaticVsKinematic", "bool", sizeof(bool), unsafe_offsetof(physx_PxBroadPhaseDesc_Pod, mDiscardStaticVsKinematic));
sg.add_field("bool mDiscardKinematicVsKinematic", "mDiscardKinematicVsKinematic", "bool", sizeof(bool), unsafe_offsetof(physx_PxBroadPhaseDesc_Pod, mDiscardKinematicVsKinematic));
sg.end_struct(sizeof(physx::PxBroadPhaseDesc));
}
};
physx_PxBroadPhaseDesc_Pod::dump_layout(sg);
struct physx_PxBroadPhaseUpdateData_Pod: public physx::PxBroadPhaseUpdateData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBroadPhaseUpdateData_Pod", "PxBroadPhaseUpdateData");
sg.add_field("uint32_t const* mCreated", "mCreated", "*const u32", sizeof(uint32_t const*), unsafe_offsetof(physx_PxBroadPhaseUpdateData_Pod, mCreated));
sg.add_field("uint32_t mNbCreated", "mNbCreated", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhaseUpdateData_Pod, mNbCreated));
sg.add_field("uint32_t const* mUpdated", "mUpdated", "*const u32", sizeof(uint32_t const*), unsafe_offsetof(physx_PxBroadPhaseUpdateData_Pod, mUpdated));
sg.add_field("uint32_t mNbUpdated", "mNbUpdated", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhaseUpdateData_Pod, mNbUpdated));
sg.add_field("uint32_t const* mRemoved", "mRemoved", "*const u32", sizeof(uint32_t const*), unsafe_offsetof(physx_PxBroadPhaseUpdateData_Pod, mRemoved));
sg.add_field("uint32_t mNbRemoved", "mNbRemoved", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhaseUpdateData_Pod, mNbRemoved));
sg.add_field("physx_PxBounds3_Pod const* mBounds", "mBounds", "*const PxBounds3", sizeof(physx::PxBounds3 const*), unsafe_offsetof(physx_PxBroadPhaseUpdateData_Pod, mBounds));
sg.add_field("uint32_t const* mGroups", "mGroups", "*const u32", sizeof(uint32_t const*), unsafe_offsetof(physx_PxBroadPhaseUpdateData_Pod, mGroups));
sg.add_field("float const* mDistances", "mDistances", "*const f32", sizeof(float const*), unsafe_offsetof(physx_PxBroadPhaseUpdateData_Pod, mDistances));
sg.add_field("uint32_t mCapacity", "mCapacity", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhaseUpdateData_Pod, mCapacity));
sg.end_struct(sizeof(physx::PxBroadPhaseUpdateData));
}
};
physx_PxBroadPhaseUpdateData_Pod::dump_layout(sg);
struct physx_PxBroadPhasePair_Pod: public physx::PxBroadPhasePair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBroadPhasePair_Pod", "PxBroadPhasePair");
sg.add_field("uint32_t mID0", "mID0", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhasePair_Pod, mID0));
sg.add_field("uint32_t mID1", "mID1", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhasePair_Pod, mID1));
sg.end_struct(sizeof(physx::PxBroadPhasePair));
}
};
physx_PxBroadPhasePair_Pod::dump_layout(sg);
struct physx_PxBroadPhaseResults_Pod: public physx::PxBroadPhaseResults {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBroadPhaseResults_Pod", "PxBroadPhaseResults");
sg.add_field("uint32_t mNbCreatedPairs", "mNbCreatedPairs", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhaseResults_Pod, mNbCreatedPairs));
sg.add_field("physx_PxBroadPhasePair_Pod const* mCreatedPairs", "mCreatedPairs", "*const PxBroadPhasePair", sizeof(physx::PxBroadPhasePair const*), unsafe_offsetof(physx_PxBroadPhaseResults_Pod, mCreatedPairs));
sg.add_field("uint32_t mNbDeletedPairs", "mNbDeletedPairs", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBroadPhaseResults_Pod, mNbDeletedPairs));
sg.add_field("physx_PxBroadPhasePair_Pod const* mDeletedPairs", "mDeletedPairs", "*const PxBroadPhasePair", sizeof(physx::PxBroadPhasePair const*), unsafe_offsetof(physx_PxBroadPhaseResults_Pod, mDeletedPairs));
sg.end_struct(sizeof(physx::PxBroadPhaseResults));
}
};
physx_PxBroadPhaseResults_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxBroadPhaseRegions_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxBroadPhase_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxAABBManager_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxBroadPhaseCallback_Pod;\n");
sg.pass_thru("struct physx_PxSimulationEventCallback_Pod;\n");
struct physx_PxSceneLimits_Pod: public physx::PxSceneLimits {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSceneLimits_Pod", "PxSceneLimits");
sg.add_field("uint32_t maxNbActors", "maxNbActors", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbActors));
sg.add_field("uint32_t maxNbBodies", "maxNbBodies", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbBodies));
sg.add_field("uint32_t maxNbStaticShapes", "maxNbStaticShapes", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbStaticShapes));
sg.add_field("uint32_t maxNbDynamicShapes", "maxNbDynamicShapes", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbDynamicShapes));
sg.add_field("uint32_t maxNbAggregates", "maxNbAggregates", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbAggregates));
sg.add_field("uint32_t maxNbConstraints", "maxNbConstraints", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbConstraints));
sg.add_field("uint32_t maxNbRegions", "maxNbRegions", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbRegions));
sg.add_field("uint32_t maxNbBroadPhaseOverlaps", "maxNbBroadPhaseOverlaps", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneLimits_Pod, maxNbBroadPhaseOverlaps));
sg.end_struct(sizeof(physx::PxSceneLimits));
}
};
physx_PxSceneLimits_Pod::dump_layout(sg);
struct physx_PxgDynamicsMemoryConfig_Pod: public physx::PxgDynamicsMemoryConfig {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxgDynamicsMemoryConfig_Pod", "PxgDynamicsMemoryConfig");
sg.add_field("uint32_t tempBufferCapacity", "tempBufferCapacity", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, tempBufferCapacity));
sg.add_field("uint32_t maxRigidContactCount", "maxRigidContactCount", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, maxRigidContactCount));
sg.add_field("uint32_t maxRigidPatchCount", "maxRigidPatchCount", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, maxRigidPatchCount));
sg.add_field("uint32_t heapCapacity", "heapCapacity", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, heapCapacity));
sg.add_field("uint32_t foundLostPairsCapacity", "foundLostPairsCapacity", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, foundLostPairsCapacity));
sg.add_field("uint32_t foundLostAggregatePairsCapacity", "foundLostAggregatePairsCapacity", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, foundLostAggregatePairsCapacity));
sg.add_field("uint32_t totalAggregatePairsCapacity", "totalAggregatePairsCapacity", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, totalAggregatePairsCapacity));
sg.add_field("uint32_t maxSoftBodyContacts", "maxSoftBodyContacts", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, maxSoftBodyContacts));
sg.add_field("uint32_t maxFemClothContacts", "maxFemClothContacts", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, maxFemClothContacts));
sg.add_field("uint32_t maxParticleContacts", "maxParticleContacts", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, maxParticleContacts));
sg.add_field("uint32_t collisionStackSize", "collisionStackSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, collisionStackSize));
sg.add_field("uint32_t maxHairContacts", "maxHairContacts", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxgDynamicsMemoryConfig_Pod, maxHairContacts));
sg.end_struct(sizeof(physx::PxgDynamicsMemoryConfig));
}
};
physx_PxgDynamicsMemoryConfig_Pod::dump_layout(sg);
struct physx_PxSceneDesc_Pod: public physx::PxSceneDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSceneDesc_Pod", "PxSceneDesc");
sg.add_field("int32_t staticStructure", "staticStructure", "PxPruningStructureType", sizeof(physx::PxPruningStructureType::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, staticStructure));
sg.add_field("int32_t dynamicStructure", "dynamicStructure", "PxPruningStructureType", sizeof(physx::PxPruningStructureType::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, dynamicStructure));
sg.add_field("uint32_t dynamicTreeRebuildRateHint", "dynamicTreeRebuildRateHint", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, dynamicTreeRebuildRateHint));
sg.add_field("int32_t dynamicTreeSecondaryPruner", "dynamicTreeSecondaryPruner", "PxDynamicTreeSecondaryPruner", sizeof(physx::PxDynamicTreeSecondaryPruner::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, dynamicTreeSecondaryPruner));
sg.add_field("int32_t staticBVHBuildStrategy", "staticBVHBuildStrategy", "PxBVHBuildStrategy", sizeof(physx::PxBVHBuildStrategy::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, staticBVHBuildStrategy));
sg.add_field("int32_t dynamicBVHBuildStrategy", "dynamicBVHBuildStrategy", "PxBVHBuildStrategy", sizeof(physx::PxBVHBuildStrategy::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, dynamicBVHBuildStrategy));
sg.add_field("uint32_t staticNbObjectsPerNode", "staticNbObjectsPerNode", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, staticNbObjectsPerNode));
sg.add_field("uint32_t dynamicNbObjectsPerNode", "dynamicNbObjectsPerNode", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, dynamicNbObjectsPerNode));
sg.add_field("int32_t sceneQueryUpdateMode", "sceneQueryUpdateMode", "PxSceneQueryUpdateMode", sizeof(physx::PxSceneQueryUpdateMode::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, sceneQueryUpdateMode));
sg.add_field("physx_PxVec3_Pod gravity", "gravity", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSceneDesc_Pod, gravity));
sg.add_field("physx_PxSimulationEventCallback_Pod* simulationEventCallback", "simulationEventCallback", "*mut PxSimulationEventCallback", sizeof(physx::PxSimulationEventCallback*), unsafe_offsetof(physx_PxSceneDesc_Pod, simulationEventCallback));
sg.add_field("physx_PxContactModifyCallback_Pod* contactModifyCallback", "contactModifyCallback", "*mut PxContactModifyCallback", sizeof(physx::PxContactModifyCallback*), unsafe_offsetof(physx_PxSceneDesc_Pod, contactModifyCallback));
sg.add_field("physx_PxCCDContactModifyCallback_Pod* ccdContactModifyCallback", "ccdContactModifyCallback", "*mut PxCCDContactModifyCallback", sizeof(physx::PxCCDContactModifyCallback*), unsafe_offsetof(physx_PxSceneDesc_Pod, ccdContactModifyCallback));
sg.add_field("void const* filterShaderData", "filterShaderData", "*const std::ffi::c_void", sizeof(void const*), unsafe_offsetof(physx_PxSceneDesc_Pod, filterShaderData));
sg.add_field("uint32_t filterShaderDataSize", "filterShaderDataSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, filterShaderDataSize));
sg.add_field("void * filterShader", "filterShader", "*mut std::ffi::c_void", sizeof(void *), unsafe_offsetof(physx_PxSceneDesc_Pod, filterShader));
sg.add_field("physx_PxSimulationFilterCallback_Pod* filterCallback", "filterCallback", "*mut PxSimulationFilterCallback", sizeof(physx::PxSimulationFilterCallback*), unsafe_offsetof(physx_PxSceneDesc_Pod, filterCallback));
sg.add_field("int32_t kineKineFilteringMode", "kineKineFilteringMode", "PxPairFilteringMode", sizeof(physx::PxPairFilteringMode::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, kineKineFilteringMode));
sg.add_field("int32_t staticKineFilteringMode", "staticKineFilteringMode", "PxPairFilteringMode", sizeof(physx::PxPairFilteringMode::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, staticKineFilteringMode));
sg.add_field("int32_t broadPhaseType", "broadPhaseType", "PxBroadPhaseType", sizeof(physx::PxBroadPhaseType::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, broadPhaseType));
sg.add_field("physx_PxBroadPhaseCallback_Pod* broadPhaseCallback", "broadPhaseCallback", "*mut PxBroadPhaseCallback", sizeof(physx::PxBroadPhaseCallback*), unsafe_offsetof(physx_PxSceneDesc_Pod, broadPhaseCallback));
sg.add_field("physx_PxSceneLimits_Pod limits", "limits", "PxSceneLimits", sizeof(physx::PxSceneLimits), unsafe_offsetof(physx_PxSceneDesc_Pod, limits));
sg.add_field("int32_t frictionType", "frictionType", "PxFrictionType", sizeof(physx::PxFrictionType::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, frictionType));
sg.add_field("int32_t solverType", "solverType", "PxSolverType", sizeof(physx::PxSolverType::Enum), unsafe_offsetof(physx_PxSceneDesc_Pod, solverType));
sg.add_field("float bounceThresholdVelocity", "bounceThresholdVelocity", "f32", sizeof(float), unsafe_offsetof(physx_PxSceneDesc_Pod, bounceThresholdVelocity));
sg.add_field("float frictionOffsetThreshold", "frictionOffsetThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxSceneDesc_Pod, frictionOffsetThreshold));
sg.add_field("float frictionCorrelationDistance", "frictionCorrelationDistance", "f32", sizeof(float), unsafe_offsetof(physx_PxSceneDesc_Pod, frictionCorrelationDistance));
sg.add_field("uint32_t flags", "flags", "PxSceneFlags", sizeof(physx::PxSceneFlags), unsafe_offsetof(physx_PxSceneDesc_Pod, flags));
sg.add_field("physx_PxCpuDispatcher_Pod* cpuDispatcher", "cpuDispatcher", "*mut PxCpuDispatcher", sizeof(physx::PxCpuDispatcher*), unsafe_offsetof(physx_PxSceneDesc_Pod, cpuDispatcher));
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxSceneDesc_Pod, userData));
sg.add_field("uint32_t solverBatchSize", "solverBatchSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, solverBatchSize));
sg.add_field("uint32_t solverArticulationBatchSize", "solverArticulationBatchSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, solverArticulationBatchSize));
sg.add_field("uint32_t nbContactDataBlocks", "nbContactDataBlocks", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, nbContactDataBlocks));
sg.add_field("uint32_t maxNbContactDataBlocks", "maxNbContactDataBlocks", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, maxNbContactDataBlocks));
sg.add_field("float maxBiasCoefficient", "maxBiasCoefficient", "f32", sizeof(float), unsafe_offsetof(physx_PxSceneDesc_Pod, maxBiasCoefficient));
sg.add_field("uint32_t contactReportStreamBufferSize", "contactReportStreamBufferSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, contactReportStreamBufferSize));
sg.add_field("uint32_t ccdMaxPasses", "ccdMaxPasses", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, ccdMaxPasses));
sg.add_field("float ccdThreshold", "ccdThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxSceneDesc_Pod, ccdThreshold));
sg.add_field("float ccdMaxSeparation", "ccdMaxSeparation", "f32", sizeof(float), unsafe_offsetof(physx_PxSceneDesc_Pod, ccdMaxSeparation));
sg.add_field("float wakeCounterResetValue", "wakeCounterResetValue", "f32", sizeof(float), unsafe_offsetof(physx_PxSceneDesc_Pod, wakeCounterResetValue));
sg.add_field("physx_PxBounds3_Pod sanityBounds", "sanityBounds", "PxBounds3", sizeof(physx::PxBounds3), unsafe_offsetof(physx_PxSceneDesc_Pod, sanityBounds));
sg.add_field("physx_PxgDynamicsMemoryConfig_Pod gpuDynamicsConfig", "gpuDynamicsConfig", "PxgDynamicsMemoryConfig", sizeof(physx::PxgDynamicsMemoryConfig), unsafe_offsetof(physx_PxSceneDesc_Pod, gpuDynamicsConfig));
sg.add_field("uint32_t gpuMaxNumPartitions", "gpuMaxNumPartitions", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, gpuMaxNumPartitions));
sg.add_field("uint32_t gpuMaxNumStaticPartitions", "gpuMaxNumStaticPartitions", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, gpuMaxNumStaticPartitions));
sg.add_field("uint32_t gpuComputeVersion", "gpuComputeVersion", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, gpuComputeVersion));
sg.add_field("uint32_t contactPairSlabSize", "contactPairSlabSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSceneDesc_Pod, contactPairSlabSize));
sg.add_field("physx_PxSceneQuerySystem_Pod* sceneQuerySystem", "sceneQuerySystem", "*mut PxSceneQuerySystem", sizeof(physx::PxSceneQuerySystem*), unsafe_offsetof(physx_PxSceneDesc_Pod, sceneQuerySystem));
sg.end_struct(sizeof(physx::PxSceneDesc));
}
};
physx_PxSceneDesc_Pod::dump_layout(sg);
struct physx_PxSimulationStatistics_Pod: public physx::PxSimulationStatistics {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSimulationStatistics_Pod", "PxSimulationStatistics");
sg.add_field("uint32_t nbActiveConstraints", "nbActiveConstraints", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbActiveConstraints));
sg.add_field("uint32_t nbActiveDynamicBodies", "nbActiveDynamicBodies", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbActiveDynamicBodies));
sg.add_field("uint32_t nbActiveKinematicBodies", "nbActiveKinematicBodies", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbActiveKinematicBodies));
sg.add_field("uint32_t nbStaticBodies", "nbStaticBodies", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbStaticBodies));
sg.add_field("uint32_t nbDynamicBodies", "nbDynamicBodies", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbDynamicBodies));
sg.add_field("uint32_t nbKinematicBodies", "nbKinematicBodies", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbKinematicBodies));
sg.add_field("uint32_t nbShapes[11]", "nbShapes", "[u32; 11]", sizeof(uint32_t[11]), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbShapes));
sg.add_field("uint32_t nbAggregates", "nbAggregates", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbAggregates));
sg.add_field("uint32_t nbArticulations", "nbArticulations", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbArticulations));
sg.add_field("uint32_t nbAxisSolverConstraints", "nbAxisSolverConstraints", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbAxisSolverConstraints));
sg.add_field("uint32_t compressedContactSize", "compressedContactSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, compressedContactSize));
sg.add_field("uint32_t requiredContactConstraintMemory", "requiredContactConstraintMemory", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, requiredContactConstraintMemory));
sg.add_field("uint32_t peakConstraintMemory", "peakConstraintMemory", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, peakConstraintMemory));
sg.add_field("uint32_t nbDiscreteContactPairsTotal", "nbDiscreteContactPairsTotal", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbDiscreteContactPairsTotal));
sg.add_field("uint32_t nbDiscreteContactPairsWithCacheHits", "nbDiscreteContactPairsWithCacheHits", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbDiscreteContactPairsWithCacheHits));
sg.add_field("uint32_t nbDiscreteContactPairsWithContacts", "nbDiscreteContactPairsWithContacts", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbDiscreteContactPairsWithContacts));
sg.add_field("uint32_t nbNewPairs", "nbNewPairs", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbNewPairs));
sg.add_field("uint32_t nbLostPairs", "nbLostPairs", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbLostPairs));
sg.add_field("uint32_t nbNewTouches", "nbNewTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbNewTouches));
sg.add_field("uint32_t nbLostTouches", "nbLostTouches", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbLostTouches));
sg.add_field("uint32_t nbPartitions", "nbPartitions", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbPartitions));
sg.add_field("uint64_t gpuMemParticles", "gpuMemParticles", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemParticles));
sg.add_field("uint64_t gpuMemSoftBodies", "gpuMemSoftBodies", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemSoftBodies));
sg.add_field("uint64_t gpuMemFEMCloths", "gpuMemFEMCloths", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemFEMCloths));
sg.add_field("uint64_t gpuMemHairSystems", "gpuMemHairSystems", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHairSystems));
sg.add_field("uint64_t gpuMemHeap", "gpuMemHeap", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeap));
sg.add_field("uint64_t gpuMemHeapBroadPhase", "gpuMemHeapBroadPhase", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapBroadPhase));
sg.add_field("uint64_t gpuMemHeapNarrowPhase", "gpuMemHeapNarrowPhase", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapNarrowPhase));
sg.add_field("uint64_t gpuMemHeapSolver", "gpuMemHeapSolver", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapSolver));
sg.add_field("uint64_t gpuMemHeapArticulation", "gpuMemHeapArticulation", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapArticulation));
sg.add_field("uint64_t gpuMemHeapSimulation", "gpuMemHeapSimulation", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapSimulation));
sg.add_field("uint64_t gpuMemHeapSimulationArticulation", "gpuMemHeapSimulationArticulation", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapSimulationArticulation));
sg.add_field("uint64_t gpuMemHeapSimulationParticles", "gpuMemHeapSimulationParticles", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapSimulationParticles));
sg.add_field("uint64_t gpuMemHeapSimulationSoftBody", "gpuMemHeapSimulationSoftBody", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapSimulationSoftBody));
sg.add_field("uint64_t gpuMemHeapSimulationFEMCloth", "gpuMemHeapSimulationFEMCloth", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapSimulationFEMCloth));
sg.add_field("uint64_t gpuMemHeapSimulationHairSystem", "gpuMemHeapSimulationHairSystem", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapSimulationHairSystem));
sg.add_field("uint64_t gpuMemHeapParticles", "gpuMemHeapParticles", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapParticles));
sg.add_field("uint64_t gpuMemHeapSoftBodies", "gpuMemHeapSoftBodies", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapSoftBodies));
sg.add_field("uint64_t gpuMemHeapFEMCloths", "gpuMemHeapFEMCloths", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapFEMCloths));
sg.add_field("uint64_t gpuMemHeapHairSystems", "gpuMemHeapHairSystems", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapHairSystems));
sg.add_field("uint64_t gpuMemHeapOther", "gpuMemHeapOther", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, gpuMemHeapOther));
sg.add_field("uint32_t nbBroadPhaseAdds", "nbBroadPhaseAdds", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbBroadPhaseAdds));
sg.add_field("uint32_t nbBroadPhaseRemoves", "nbBroadPhaseRemoves", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbBroadPhaseRemoves));
sg.add_field("uint32_t nbDiscreteContactPairs[11][11]", "nbDiscreteContactPairs", "[[u32; 11]; 11]", sizeof(uint32_t[11][11]), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbDiscreteContactPairs));
sg.add_field("uint32_t nbCCDPairs[11][11]", "nbCCDPairs", "[[u32; 11]; 11]", sizeof(uint32_t[11][11]), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbCCDPairs));
sg.add_field("uint32_t nbModifiedContactPairs[11][11]", "nbModifiedContactPairs", "[[u32; 11]; 11]", sizeof(uint32_t[11][11]), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbModifiedContactPairs));
sg.add_field("uint32_t nbTriggerPairs[11][11]", "nbTriggerPairs", "[[u32; 11]; 11]", sizeof(uint32_t[11][11]), unsafe_offsetof(physx_PxSimulationStatistics_Pod, nbTriggerPairs));
sg.end_struct(sizeof(physx::PxSimulationStatistics));
}
};
physx_PxSimulationStatistics_Pod::dump_layout(sg);
struct physx_PxGpuBodyData_Pod: public physx::PxGpuBodyData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGpuBodyData_Pod", "PxGpuBodyData");
sg.add_field("physx_PxQuat_Pod quat", "quat", "PxQuat", sizeof(physx::PxQuat), unsafe_offsetof(physx_PxGpuBodyData_Pod, quat));
sg.add_field("physx_PxVec4_Pod pos", "pos", "PxVec4", sizeof(physx::PxVec4), unsafe_offsetof(physx_PxGpuBodyData_Pod, pos));
sg.add_field("physx_PxVec4_Pod linVel", "linVel", "PxVec4", sizeof(physx::PxVec4), unsafe_offsetof(physx_PxGpuBodyData_Pod, linVel));
sg.add_field("physx_PxVec4_Pod angVel", "angVel", "PxVec4", sizeof(physx::PxVec4), unsafe_offsetof(physx_PxGpuBodyData_Pod, angVel));
sg.end_struct(sizeof(physx::PxGpuBodyData));
}
};
physx_PxGpuBodyData_Pod::dump_layout(sg);
struct physx_PxGpuActorPair_Pod: public physx::PxGpuActorPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGpuActorPair_Pod", "PxGpuActorPair");
sg.add_field("uint32_t srcIndex", "srcIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxGpuActorPair_Pod, srcIndex));
sg.add_field("physx_PxNodeIndex_Pod nodeIndex", "nodeIndex", "PxNodeIndex", sizeof(physx::PxNodeIndex), unsafe_offsetof(physx_PxGpuActorPair_Pod, nodeIndex));
sg.end_struct(sizeof(physx::PxGpuActorPair));
}
};
physx_PxGpuActorPair_Pod::dump_layout(sg);
struct physx_PxIndexDataPair_Pod: public physx::PxIndexDataPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxIndexDataPair_Pod", "PxIndexDataPair");
sg.add_field("uint32_t index", "index", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxIndexDataPair_Pod, index));
sg.add_field("void* data", "data", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxIndexDataPair_Pod, data));
sg.end_struct(sizeof(physx::PxIndexDataPair));
}
};
physx_PxIndexDataPair_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxPvdSceneClient_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxContactPairHeader_Pod;\n");
struct physx_PxDominanceGroupPair_Pod: public physx::PxDominanceGroupPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDominanceGroupPair_Pod", "PxDominanceGroupPair");
sg.add_field("uint8_t dominance0", "dominance0", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxDominanceGroupPair_Pod, dominance0));
sg.add_field("uint8_t dominance1", "dominance1", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxDominanceGroupPair_Pod, dominance1));
sg.end_struct(sizeof(physx::PxDominanceGroupPair));
}
};
physx_PxDominanceGroupPair_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxBroadPhaseCallback_Pod {\n void* vtable_;\n};\n");
struct physx_PxScene_Pod: public physx::PxScene {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxScene_Pod", "PxScene");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxScene_Pod, userData));
sg.end_struct(sizeof(physx::PxScene));
}
};
physx_PxScene_Pod::dump_layout(sg);
struct physx_PxSceneReadLock_Pod: public physx::PxSceneReadLock {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSceneReadLock_Pod", "PxSceneReadLock");
sg.end_struct(sizeof(physx::PxSceneReadLock));
}
};
physx_PxSceneReadLock_Pod::dump_layout(sg);
struct physx_PxSceneWriteLock_Pod: public physx::PxSceneWriteLock {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSceneWriteLock_Pod", "PxSceneWriteLock");
sg.end_struct(sizeof(physx::PxSceneWriteLock));
}
};
physx_PxSceneWriteLock_Pod::dump_layout(sg);
struct physx_PxContactPairExtraDataItem_Pod: public physx::PxContactPairExtraDataItem {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactPairExtraDataItem_Pod", "PxContactPairExtraDataItem");
sg.add_field("uint8_t type", "type_", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxContactPairExtraDataItem_Pod, type));
sg.end_struct(sizeof(physx::PxContactPairExtraDataItem));
}
};
physx_PxContactPairExtraDataItem_Pod::dump_layout(sg);
struct physx_PxContactPairVelocity_Pod: public physx::PxContactPairVelocity {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactPairVelocity_Pod", "PxContactPairVelocity");
sg.add_field("uint8_t type", "type_", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxContactPairVelocity_Pod, type));
sg.add_field("physx_PxVec3_Pod linearVelocity[2]", "linearVelocity", "[PxVec3; 2]", sizeof(physx::PxVec3[2]), unsafe_offsetof(physx_PxContactPairVelocity_Pod, linearVelocity));
sg.add_field("physx_PxVec3_Pod angularVelocity[2]", "angularVelocity", "[PxVec3; 2]", sizeof(physx::PxVec3[2]), unsafe_offsetof(physx_PxContactPairVelocity_Pod, angularVelocity));
sg.end_struct(sizeof(physx::PxContactPairVelocity));
}
};
physx_PxContactPairVelocity_Pod::dump_layout(sg);
struct physx_PxContactPairPose_Pod: public physx::PxContactPairPose {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactPairPose_Pod", "PxContactPairPose");
sg.add_field("uint8_t type", "type_", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxContactPairPose_Pod, type));
sg.add_field("physx_PxTransform_Pod globalPose[2]", "globalPose", "[PxTransform; 2]", sizeof(physx::PxTransform[2]), unsafe_offsetof(physx_PxContactPairPose_Pod, globalPose));
sg.end_struct(sizeof(physx::PxContactPairPose));
}
};
physx_PxContactPairPose_Pod::dump_layout(sg);
struct physx_PxContactPairIndex_Pod: public physx::PxContactPairIndex {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactPairIndex_Pod", "PxContactPairIndex");
sg.add_field("uint8_t type", "type_", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxContactPairIndex_Pod, type));
sg.add_field("uint16_t index", "index", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxContactPairIndex_Pod, index));
sg.end_struct(sizeof(physx::PxContactPairIndex));
}
};
physx_PxContactPairIndex_Pod::dump_layout(sg);
struct physx_PxContactPairExtraDataIterator_Pod: public physx::PxContactPairExtraDataIterator {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactPairExtraDataIterator_Pod", "PxContactPairExtraDataIterator");
sg.add_field("uint8_t const* currPtr", "currPtr", "*const u8", sizeof(uint8_t const*), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, currPtr));
sg.add_field("uint8_t const* endPtr", "endPtr", "*const u8", sizeof(uint8_t const*), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, endPtr));
sg.add_field("physx_PxContactPairVelocity_Pod const* preSolverVelocity", "preSolverVelocity", "*const PxContactPairVelocity", sizeof(physx::PxContactPairVelocity const*), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, preSolverVelocity));
sg.add_field("physx_PxContactPairVelocity_Pod const* postSolverVelocity", "postSolverVelocity", "*const PxContactPairVelocity", sizeof(physx::PxContactPairVelocity const*), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, postSolverVelocity));
sg.add_field("physx_PxContactPairPose_Pod const* eventPose", "eventPose", "*const PxContactPairPose", sizeof(physx::PxContactPairPose const*), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, eventPose));
sg.add_field("uint32_t contactPairIndex", "contactPairIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactPairExtraDataIterator_Pod, contactPairIndex));
sg.end_struct(sizeof(physx::PxContactPairExtraDataIterator));
}
};
physx_PxContactPairExtraDataIterator_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxContactPair_Pod;\n");
struct physx_PxContactPairHeader_Pod: public physx::PxContactPairHeader {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactPairHeader_Pod", "PxContactPairHeader");
sg.add_field("physx_PxActor_Pod* actors[2]", "actors", "[*mut PxActor; 2]", sizeof(physx::PxActor*[2]), unsafe_offsetof(physx_PxContactPairHeader_Pod, actors));
sg.add_field("uint8_t const* extraDataStream", "extraDataStream", "*const u8", sizeof(uint8_t const*), unsafe_offsetof(physx_PxContactPairHeader_Pod, extraDataStream));
sg.add_field("uint16_t extraDataStreamSize", "extraDataStreamSize", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxContactPairHeader_Pod, extraDataStreamSize));
sg.add_field("uint16_t flags", "flags", "PxContactPairHeaderFlags", sizeof(physx::PxContactPairHeaderFlags), unsafe_offsetof(physx_PxContactPairHeader_Pod, flags));
sg.add_field("physx_PxContactPair_Pod const* pairs", "pairs", "*const PxContactPair", sizeof(physx::PxContactPair const*), unsafe_offsetof(physx_PxContactPairHeader_Pod, pairs));
sg.add_field("uint32_t nbPairs", "nbPairs", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactPairHeader_Pod, nbPairs));
sg.end_struct(sizeof(physx::PxContactPairHeader));
}
};
physx_PxContactPairHeader_Pod::dump_layout(sg);
struct physx_PxContactPairPoint_Pod: public physx::PxContactPairPoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactPairPoint_Pod", "PxContactPairPoint");
sg.add_field("physx_PxVec3_Pod position", "position", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactPairPoint_Pod, position));
sg.add_field("float separation", "separation", "f32", sizeof(float), unsafe_offsetof(physx_PxContactPairPoint_Pod, separation));
sg.add_field("physx_PxVec3_Pod normal", "normal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactPairPoint_Pod, normal));
sg.add_field("uint32_t internalFaceIndex0", "internalFaceIndex0", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactPairPoint_Pod, internalFaceIndex0));
sg.add_field("physx_PxVec3_Pod impulse", "impulse", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxContactPairPoint_Pod, impulse));
sg.add_field("uint32_t internalFaceIndex1", "internalFaceIndex1", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactPairPoint_Pod, internalFaceIndex1));
sg.end_struct(sizeof(physx::PxContactPairPoint));
}
};
physx_PxContactPairPoint_Pod::dump_layout(sg);
struct physx_PxContactPair_Pod: public physx::PxContactPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactPair_Pod", "PxContactPair");
sg.add_field("physx_PxShape_Pod* shapes[2]", "shapes", "[*mut PxShape; 2]", sizeof(physx::PxShape*[2]), unsafe_offsetof(physx_PxContactPair_Pod, shapes));
sg.add_field("uint8_t const* contactPatches", "contactPatches", "*const u8", sizeof(uint8_t const*), unsafe_offsetof(physx_PxContactPair_Pod, contactPatches));
sg.add_field("uint8_t const* contactPoints", "contactPoints", "*const u8", sizeof(uint8_t const*), unsafe_offsetof(physx_PxContactPair_Pod, contactPoints));
sg.add_field("float const* contactImpulses", "contactImpulses", "*const f32", sizeof(float const*), unsafe_offsetof(physx_PxContactPair_Pod, contactImpulses));
sg.add_field("uint32_t requiredBufferSize", "requiredBufferSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxContactPair_Pod, requiredBufferSize));
sg.add_field("uint8_t contactCount", "contactCount", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxContactPair_Pod, contactCount));
sg.add_field("uint8_t patchCount", "patchCount", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxContactPair_Pod, patchCount));
sg.add_field("uint16_t contactStreamSize", "contactStreamSize", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxContactPair_Pod, contactStreamSize));
sg.add_field("uint16_t flags", "flags", "PxContactPairFlags", sizeof(physx::PxContactPairFlags), unsafe_offsetof(physx_PxContactPair_Pod, flags));
sg.add_field("uint16_t events", "events", "PxPairFlags", sizeof(physx::PxPairFlags), unsafe_offsetof(physx_PxContactPair_Pod, events));
sg.add_field("uint32_t internalData[2]", "internalData", "[u32; 2]", sizeof(uint32_t[2]), unsafe_offsetof(physx_PxContactPair_Pod, internalData));
sg.end_struct(sizeof(physx::PxContactPair));
}
};
physx_PxContactPair_Pod::dump_layout(sg);
struct physx_PxTriggerPair_Pod: public physx::PxTriggerPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTriggerPair_Pod", "PxTriggerPair");
sg.add_field("physx_PxShape_Pod* triggerShape", "triggerShape", "*mut PxShape", sizeof(physx::PxShape*), unsafe_offsetof(physx_PxTriggerPair_Pod, triggerShape));
sg.add_field("physx_PxActor_Pod* triggerActor", "triggerActor", "*mut PxActor", sizeof(physx::PxActor*), unsafe_offsetof(physx_PxTriggerPair_Pod, triggerActor));
sg.add_field("physx_PxShape_Pod* otherShape", "otherShape", "*mut PxShape", sizeof(physx::PxShape*), unsafe_offsetof(physx_PxTriggerPair_Pod, otherShape));
sg.add_field("physx_PxActor_Pod* otherActor", "otherActor", "*mut PxActor", sizeof(physx::PxActor*), unsafe_offsetof(physx_PxTriggerPair_Pod, otherActor));
sg.add_field("int32_t status", "status", "PxPairFlag", sizeof(physx::PxPairFlag::Enum), unsafe_offsetof(physx_PxTriggerPair_Pod, status));
sg.add_field("uint8_t flags", "flags", "PxTriggerPairFlags", sizeof(physx::PxTriggerPairFlags), unsafe_offsetof(physx_PxTriggerPair_Pod, flags));
sg.end_struct(sizeof(physx::PxTriggerPair));
}
};
physx_PxTriggerPair_Pod::dump_layout(sg);
struct physx_PxConstraintInfo_Pod: public physx::PxConstraintInfo {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxConstraintInfo_Pod", "PxConstraintInfo");
sg.add_field("physx_PxConstraint_Pod* constraint", "constraint", "*mut PxConstraint", sizeof(physx::PxConstraint*), unsafe_offsetof(physx_PxConstraintInfo_Pod, constraint));
sg.add_field("void* externalReference", "externalReference", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxConstraintInfo_Pod, externalReference));
sg.add_field("uint32_t type", "type_", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxConstraintInfo_Pod, type));
sg.end_struct(sizeof(physx::PxConstraintInfo));
}
};
physx_PxConstraintInfo_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxSimulationEventCallback_Pod {\n void* vtable_;\n};\n");
struct physx_PxFEMParameters_Pod: public physx::PxFEMParameters {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxFEMParameters_Pod", "PxFEMParameters");
sg.add_field("float velocityDamping", "velocityDamping", "f32", sizeof(float), unsafe_offsetof(physx_PxFEMParameters_Pod, velocityDamping));
sg.add_field("float settlingThreshold", "settlingThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxFEMParameters_Pod, settlingThreshold));
sg.add_field("float sleepThreshold", "sleepThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxFEMParameters_Pod, sleepThreshold));
sg.add_field("float sleepDamping", "sleepDamping", "f32", sizeof(float), unsafe_offsetof(physx_PxFEMParameters_Pod, sleepDamping));
sg.add_field("float selfCollisionFilterDistance", "selfCollisionFilterDistance", "f32", sizeof(float), unsafe_offsetof(physx_PxFEMParameters_Pod, selfCollisionFilterDistance));
sg.add_field("float selfCollisionStressTolerance", "selfCollisionStressTolerance", "f32", sizeof(float), unsafe_offsetof(physx_PxFEMParameters_Pod, selfCollisionStressTolerance));
sg.end_struct(sizeof(physx::PxFEMParameters));
}
};
physx_PxFEMParameters_Pod::dump_layout(sg);
struct physx_PxPruningStructure_Pod: public physx::PxPruningStructure {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxPruningStructure_Pod", "PxPruningStructure");
sg.end_struct(sizeof(physx::PxPruningStructure));
}
};
physx_PxPruningStructure_Pod::dump_layout(sg);
struct physx_PxExtendedVec3_Pod: public physx::PxExtendedVec3 {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxExtendedVec3_Pod", "PxExtendedVec3");
sg.add_field("double x", "x", "f64", sizeof(double), unsafe_offsetof(physx_PxExtendedVec3_Pod, x));
sg.add_field("double y", "y", "f64", sizeof(double), unsafe_offsetof(physx_PxExtendedVec3_Pod, y));
sg.add_field("double z", "z", "f64", sizeof(double), unsafe_offsetof(physx_PxExtendedVec3_Pod, z));
sg.end_struct(sizeof(physx::PxExtendedVec3));
}
};
physx_PxExtendedVec3_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxControllerManager_Pod;\n");
struct physx_PxObstacle_Pod: public physx::PxObstacle {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxObstacle_Pod", "PxObstacle");
sg.add_field("void* mUserData", "mUserData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxObstacle_Pod, mUserData));
sg.add_field("physx_PxExtendedVec3_Pod mPos", "mPos", "PxExtendedVec3", sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxObstacle_Pod, mPos));
sg.add_field("physx_PxQuat_Pod mRot", "mRot", "PxQuat", sizeof(physx::PxQuat), unsafe_offsetof(physx_PxObstacle_Pod, mRot));
sg.end_struct(sizeof(physx::PxObstacle));
}
};
physx_PxObstacle_Pod::dump_layout(sg);
struct physx_PxBoxObstacle_Pod: public physx::PxBoxObstacle {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBoxObstacle_Pod", "PxBoxObstacle");
sg.add_field("void* mUserData", "mUserData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxBoxObstacle_Pod, mUserData));
sg.add_field("physx_PxExtendedVec3_Pod mPos", "mPos", "PxExtendedVec3", sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxBoxObstacle_Pod, mPos));
sg.add_field("physx_PxQuat_Pod mRot", "mRot", "PxQuat", sizeof(physx::PxQuat), unsafe_offsetof(physx_PxBoxObstacle_Pod, mRot));
sg.add_field("physx_PxVec3_Pod mHalfExtents", "mHalfExtents", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxBoxObstacle_Pod, mHalfExtents));
sg.end_struct(sizeof(physx::PxBoxObstacle));
}
};
physx_PxBoxObstacle_Pod::dump_layout(sg);
struct physx_PxCapsuleObstacle_Pod: public physx::PxCapsuleObstacle {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxCapsuleObstacle_Pod", "PxCapsuleObstacle");
sg.add_field("void* mUserData", "mUserData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxCapsuleObstacle_Pod, mUserData));
sg.add_field("physx_PxExtendedVec3_Pod mPos", "mPos", "PxExtendedVec3", sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxCapsuleObstacle_Pod, mPos));
sg.add_field("physx_PxQuat_Pod mRot", "mRot", "PxQuat", sizeof(physx::PxQuat), unsafe_offsetof(physx_PxCapsuleObstacle_Pod, mRot));
sg.add_field("float mHalfHeight", "mHalfHeight", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleObstacle_Pod, mHalfHeight));
sg.add_field("float mRadius", "mRadius", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleObstacle_Pod, mRadius));
sg.end_struct(sizeof(physx::PxCapsuleObstacle));
}
};
physx_PxCapsuleObstacle_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxObstacleContext_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxController_Pod;\n");
sg.pass_thru("struct physx_PxControllerBehaviorCallback_Pod;\n");
struct physx_PxControllerState_Pod: public physx::PxControllerState {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxControllerState_Pod", "PxControllerState");
sg.add_field("physx_PxVec3_Pod deltaXP", "deltaXP", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerState_Pod, deltaXP));
sg.add_field("physx_PxShape_Pod* touchedShape", "touchedShape", "*mut PxShape", sizeof(physx::PxShape*), unsafe_offsetof(physx_PxControllerState_Pod, touchedShape));
sg.add_field("physx_PxRigidActor_Pod* touchedActor", "touchedActor", "*mut PxRigidActor", sizeof(physx::PxRigidActor*), unsafe_offsetof(physx_PxControllerState_Pod, touchedActor));
sg.add_field("uint32_t touchedObstacleHandle", "touchedObstacleHandle", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxControllerState_Pod, touchedObstacleHandle));
sg.add_field("uint32_t collisionFlags", "collisionFlags", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxControllerState_Pod, collisionFlags));
sg.add_field("bool standOnAnotherCCT", "standOnAnotherCCT", "bool", sizeof(bool), unsafe_offsetof(physx_PxControllerState_Pod, standOnAnotherCCT));
sg.add_field("bool standOnObstacle", "standOnObstacle", "bool", sizeof(bool), unsafe_offsetof(physx_PxControllerState_Pod, standOnObstacle));
sg.add_field("bool isMovingUp", "isMovingUp", "bool", sizeof(bool), unsafe_offsetof(physx_PxControllerState_Pod, isMovingUp));
sg.end_struct(sizeof(physx::PxControllerState));
}
};
physx_PxControllerState_Pod::dump_layout(sg);
struct physx_PxControllerStats_Pod: public physx::PxControllerStats {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxControllerStats_Pod", "PxControllerStats");
sg.add_field("uint16_t nbIterations", "nbIterations", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxControllerStats_Pod, nbIterations));
sg.add_field("uint16_t nbFullUpdates", "nbFullUpdates", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxControllerStats_Pod, nbFullUpdates));
sg.add_field("uint16_t nbPartialUpdates", "nbPartialUpdates", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxControllerStats_Pod, nbPartialUpdates));
sg.add_field("uint16_t nbTessellation", "nbTessellation", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxControllerStats_Pod, nbTessellation));
sg.end_struct(sizeof(physx::PxControllerStats));
}
};
physx_PxControllerStats_Pod::dump_layout(sg);
struct physx_PxControllerHit_Pod: public physx::PxControllerHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxControllerHit_Pod", "PxControllerHit");
sg.add_field("physx_PxController_Pod* controller", "controller", "*mut PxController", sizeof(physx::PxController*), unsafe_offsetof(physx_PxControllerHit_Pod, controller));
sg.add_field("physx_PxExtendedVec3_Pod worldPos", "worldPos", "PxExtendedVec3", sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxControllerHit_Pod, worldPos));
sg.add_field("physx_PxVec3_Pod worldNormal", "worldNormal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerHit_Pod, worldNormal));
sg.add_field("physx_PxVec3_Pod dir", "dir", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerHit_Pod, dir));
sg.add_field("float length", "length", "f32", sizeof(float), unsafe_offsetof(physx_PxControllerHit_Pod, length));
sg.end_struct(sizeof(physx::PxControllerHit));
}
};
physx_PxControllerHit_Pod::dump_layout(sg);
struct physx_PxControllerShapeHit_Pod: public physx::PxControllerShapeHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxControllerShapeHit_Pod", "PxControllerShapeHit");
sg.add_field("physx_PxController_Pod* controller", "controller", "*mut PxController", sizeof(physx::PxController*), unsafe_offsetof(physx_PxControllerShapeHit_Pod, controller));
sg.add_field("physx_PxExtendedVec3_Pod worldPos", "worldPos", "PxExtendedVec3", sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxControllerShapeHit_Pod, worldPos));
sg.add_field("physx_PxVec3_Pod worldNormal", "worldNormal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerShapeHit_Pod, worldNormal));
sg.add_field("physx_PxVec3_Pod dir", "dir", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerShapeHit_Pod, dir));
sg.add_field("float length", "length", "f32", sizeof(float), unsafe_offsetof(physx_PxControllerShapeHit_Pod, length));
sg.add_field("physx_PxShape_Pod* shape", "shape", "*mut PxShape", sizeof(physx::PxShape*), unsafe_offsetof(physx_PxControllerShapeHit_Pod, shape));
sg.add_field("physx_PxRigidActor_Pod* actor", "actor", "*mut PxRigidActor", sizeof(physx::PxRigidActor*), unsafe_offsetof(physx_PxControllerShapeHit_Pod, actor));
sg.add_field("uint32_t triangleIndex", "triangleIndex", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxControllerShapeHit_Pod, triangleIndex));
sg.end_struct(sizeof(physx::PxControllerShapeHit));
}
};
physx_PxControllerShapeHit_Pod::dump_layout(sg);
struct physx_PxControllersHit_Pod: public physx::PxControllersHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxControllersHit_Pod", "PxControllersHit");
sg.add_field("physx_PxController_Pod* controller", "controller", "*mut PxController", sizeof(physx::PxController*), unsafe_offsetof(physx_PxControllersHit_Pod, controller));
sg.add_field("physx_PxExtendedVec3_Pod worldPos", "worldPos", "PxExtendedVec3", sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxControllersHit_Pod, worldPos));
sg.add_field("physx_PxVec3_Pod worldNormal", "worldNormal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllersHit_Pod, worldNormal));
sg.add_field("physx_PxVec3_Pod dir", "dir", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllersHit_Pod, dir));
sg.add_field("float length", "length", "f32", sizeof(float), unsafe_offsetof(physx_PxControllersHit_Pod, length));
sg.add_field("physx_PxController_Pod* other", "other", "*mut PxController", sizeof(physx::PxController*), unsafe_offsetof(physx_PxControllersHit_Pod, other));
sg.end_struct(sizeof(physx::PxControllersHit));
}
};
physx_PxControllersHit_Pod::dump_layout(sg);
struct physx_PxControllerObstacleHit_Pod: public physx::PxControllerObstacleHit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxControllerObstacleHit_Pod", "PxControllerObstacleHit");
sg.add_field("physx_PxController_Pod* controller", "controller", "*mut PxController", sizeof(physx::PxController*), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, controller));
sg.add_field("physx_PxExtendedVec3_Pod worldPos", "worldPos", "PxExtendedVec3", sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, worldPos));
sg.add_field("physx_PxVec3_Pod worldNormal", "worldNormal", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, worldNormal));
sg.add_field("physx_PxVec3_Pod dir", "dir", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, dir));
sg.add_field("float length", "length", "f32", sizeof(float), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, length));
sg.add_field("void const* userData", "userData", "*const std::ffi::c_void", sizeof(void const*), unsafe_offsetof(physx_PxControllerObstacleHit_Pod, userData));
sg.end_struct(sizeof(physx::PxControllerObstacleHit));
}
};
physx_PxControllerObstacleHit_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxUserControllerHitReport_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxControllerFilterCallback_Pod {\n void* vtable_;\n};\n");
struct physx_PxControllerFilters_Pod: public physx::PxControllerFilters {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxControllerFilters_Pod", "PxControllerFilters");
sg.add_field("physx_PxFilterData_Pod const* mFilterData", "mFilterData", "*const PxFilterData", sizeof(physx::PxFilterData const*), unsafe_offsetof(physx_PxControllerFilters_Pod, mFilterData));
sg.add_field("physx_PxQueryFilterCallback_Pod* mFilterCallback", "mFilterCallback", "*mut PxQueryFilterCallback", sizeof(physx::PxQueryFilterCallback*), unsafe_offsetof(physx_PxControllerFilters_Pod, mFilterCallback));
sg.add_field("uint16_t mFilterFlags", "mFilterFlags", "PxQueryFlags", sizeof(physx::PxQueryFlags), unsafe_offsetof(physx_PxControllerFilters_Pod, mFilterFlags));
sg.add_field("physx_PxControllerFilterCallback_Pod* mCCTFilterCallback", "mCCTFilterCallback", "*mut PxControllerFilterCallback", sizeof(physx::PxControllerFilterCallback*), unsafe_offsetof(physx_PxControllerFilters_Pod, mCCTFilterCallback));
sg.end_struct(sizeof(physx::PxControllerFilters));
}
};
physx_PxControllerFilters_Pod::dump_layout(sg);
struct physx_PxControllerDesc_Pod: public physx::PxControllerDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxControllerDesc_Pod", "PxControllerDesc");
sg.add_field("physx_PxExtendedVec3_Pod position", "position", "PxExtendedVec3", sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxControllerDesc_Pod, position));
sg.add_field("physx_PxVec3_Pod upDirection", "upDirection", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxControllerDesc_Pod, upDirection));
sg.add_field("float slopeLimit", "slopeLimit", "f32", sizeof(float), unsafe_offsetof(physx_PxControllerDesc_Pod, slopeLimit));
sg.add_field("float invisibleWallHeight", "invisibleWallHeight", "f32", sizeof(float), unsafe_offsetof(physx_PxControllerDesc_Pod, invisibleWallHeight));
sg.add_field("float maxJumpHeight", "maxJumpHeight", "f32", sizeof(float), unsafe_offsetof(physx_PxControllerDesc_Pod, maxJumpHeight));
sg.add_field("float contactOffset", "contactOffset", "f32", sizeof(float), unsafe_offsetof(physx_PxControllerDesc_Pod, contactOffset));
sg.add_field("float stepOffset", "stepOffset", "f32", sizeof(float), unsafe_offsetof(physx_PxControllerDesc_Pod, stepOffset));
sg.add_field("float density", "density", "f32", sizeof(float), unsafe_offsetof(physx_PxControllerDesc_Pod, density));
sg.add_field("float scaleCoeff", "scaleCoeff", "f32", sizeof(float), unsafe_offsetof(physx_PxControllerDesc_Pod, scaleCoeff));
sg.add_field("float volumeGrowth", "volumeGrowth", "f32", sizeof(float), unsafe_offsetof(physx_PxControllerDesc_Pod, volumeGrowth));
sg.add_field("physx_PxUserControllerHitReport_Pod* reportCallback", "reportCallback", "*mut PxUserControllerHitReport", sizeof(physx::PxUserControllerHitReport*), unsafe_offsetof(physx_PxControllerDesc_Pod, reportCallback));
sg.add_field("physx_PxControllerBehaviorCallback_Pod* behaviorCallback", "behaviorCallback", "*mut PxControllerBehaviorCallback", sizeof(physx::PxControllerBehaviorCallback*), unsafe_offsetof(physx_PxControllerDesc_Pod, behaviorCallback));
sg.add_field("int32_t nonWalkableMode", "nonWalkableMode", "PxControllerNonWalkableMode", sizeof(physx::PxControllerNonWalkableMode::Enum), unsafe_offsetof(physx_PxControllerDesc_Pod, nonWalkableMode));
sg.add_field("physx_PxMaterial_Pod* material", "material", "*mut PxMaterial", sizeof(physx::PxMaterial*), unsafe_offsetof(physx_PxControllerDesc_Pod, material));
sg.add_field("bool registerDeletionListener", "registerDeletionListener", "bool", sizeof(bool), unsafe_offsetof(physx_PxControllerDesc_Pod, registerDeletionListener));
sg.add_field("uint8_t clientID", "clientID", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxControllerDesc_Pod, clientID));
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxControllerDesc_Pod, userData));
sg.end_struct(sizeof(physx::PxControllerDesc));
}
};
physx_PxControllerDesc_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxController_Pod {\n void* vtable_;\n};\n");
struct physx_PxBoxControllerDesc_Pod: public physx::PxBoxControllerDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBoxControllerDesc_Pod", "PxBoxControllerDesc");
sg.add_field("physx_PxExtendedVec3_Pod position", "position", "PxExtendedVec3", sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, position));
sg.add_field("physx_PxVec3_Pod upDirection", "upDirection", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, upDirection));
sg.add_field("float slopeLimit", "slopeLimit", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, slopeLimit));
sg.add_field("float invisibleWallHeight", "invisibleWallHeight", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, invisibleWallHeight));
sg.add_field("float maxJumpHeight", "maxJumpHeight", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, maxJumpHeight));
sg.add_field("float contactOffset", "contactOffset", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, contactOffset));
sg.add_field("float stepOffset", "stepOffset", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, stepOffset));
sg.add_field("float density", "density", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, density));
sg.add_field("float scaleCoeff", "scaleCoeff", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, scaleCoeff));
sg.add_field("float volumeGrowth", "volumeGrowth", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, volumeGrowth));
sg.add_field("physx_PxUserControllerHitReport_Pod* reportCallback", "reportCallback", "*mut PxUserControllerHitReport", sizeof(physx::PxUserControllerHitReport*), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, reportCallback));
sg.add_field("physx_PxControllerBehaviorCallback_Pod* behaviorCallback", "behaviorCallback", "*mut PxControllerBehaviorCallback", sizeof(physx::PxControllerBehaviorCallback*), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, behaviorCallback));
sg.add_field("int32_t nonWalkableMode", "nonWalkableMode", "PxControllerNonWalkableMode", sizeof(physx::PxControllerNonWalkableMode::Enum), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, nonWalkableMode));
sg.add_field("physx_PxMaterial_Pod* material", "material", "*mut PxMaterial", sizeof(physx::PxMaterial*), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, material));
sg.add_field("bool registerDeletionListener", "registerDeletionListener", "bool", sizeof(bool), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, registerDeletionListener));
sg.add_field("uint8_t clientID", "clientID", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, clientID));
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, userData));
sg.add_field("float halfHeight", "halfHeight", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, halfHeight));
sg.add_field("float halfSideExtent", "halfSideExtent", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, halfSideExtent));
sg.add_field("float halfForwardExtent", "halfForwardExtent", "f32", sizeof(float), unsafe_offsetof(physx_PxBoxControllerDesc_Pod, halfForwardExtent));
sg.end_struct(sizeof(physx::PxBoxControllerDesc));
}
};
physx_PxBoxControllerDesc_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxBoxController_Pod {\n void* vtable_;\n};\n");
struct physx_PxCapsuleControllerDesc_Pod: public physx::PxCapsuleControllerDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxCapsuleControllerDesc_Pod", "PxCapsuleControllerDesc");
sg.add_field("physx_PxExtendedVec3_Pod position", "position", "PxExtendedVec3", sizeof(physx::PxExtendedVec3), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, position));
sg.add_field("physx_PxVec3_Pod upDirection", "upDirection", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, upDirection));
sg.add_field("float slopeLimit", "slopeLimit", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, slopeLimit));
sg.add_field("float invisibleWallHeight", "invisibleWallHeight", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, invisibleWallHeight));
sg.add_field("float maxJumpHeight", "maxJumpHeight", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, maxJumpHeight));
sg.add_field("float contactOffset", "contactOffset", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, contactOffset));
sg.add_field("float stepOffset", "stepOffset", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, stepOffset));
sg.add_field("float density", "density", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, density));
sg.add_field("float scaleCoeff", "scaleCoeff", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, scaleCoeff));
sg.add_field("float volumeGrowth", "volumeGrowth", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, volumeGrowth));
sg.add_field("physx_PxUserControllerHitReport_Pod* reportCallback", "reportCallback", "*mut PxUserControllerHitReport", sizeof(physx::PxUserControllerHitReport*), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, reportCallback));
sg.add_field("physx_PxControllerBehaviorCallback_Pod* behaviorCallback", "behaviorCallback", "*mut PxControllerBehaviorCallback", sizeof(physx::PxControllerBehaviorCallback*), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, behaviorCallback));
sg.add_field("int32_t nonWalkableMode", "nonWalkableMode", "PxControllerNonWalkableMode", sizeof(physx::PxControllerNonWalkableMode::Enum), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, nonWalkableMode));
sg.add_field("physx_PxMaterial_Pod* material", "material", "*mut PxMaterial", sizeof(physx::PxMaterial*), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, material));
sg.add_field("bool registerDeletionListener", "registerDeletionListener", "bool", sizeof(bool), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, registerDeletionListener));
sg.add_field("uint8_t clientID", "clientID", "u8", sizeof(uint8_t), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, clientID));
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, userData));
sg.add_field("float radius", "radius", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, radius));
sg.add_field("float height", "height", "f32", sizeof(float), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, height));
sg.add_field("int32_t climbingMode", "climbingMode", "PxCapsuleClimbingMode", sizeof(physx::PxCapsuleClimbingMode::Enum), unsafe_offsetof(physx_PxCapsuleControllerDesc_Pod, climbingMode));
sg.end_struct(sizeof(physx::PxCapsuleControllerDesc));
}
};
physx_PxCapsuleControllerDesc_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxCapsuleController_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxControllerBehaviorCallback_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxControllerManager_Pod {\n void* vtable_;\n};\n");
struct physx_PxDim3_Pod: public physx::PxDim3 {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDim3_Pod", "PxDim3");
sg.add_field("uint32_t x", "x", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxDim3_Pod, x));
sg.add_field("uint32_t y", "y", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxDim3_Pod, y));
sg.add_field("uint32_t z", "z", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxDim3_Pod, z));
sg.end_struct(sizeof(physx::PxDim3));
}
};
physx_PxDim3_Pod::dump_layout(sg);
struct physx_PxSDFDesc_Pod: public physx::PxSDFDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSDFDesc_Pod", "PxSDFDesc");
sg.add_field("physx_PxBoundedData_Pod sdf", "sdf", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxSDFDesc_Pod, sdf));
sg.add_field("physx_PxDim3_Pod dims", "dims", "PxDim3", sizeof(physx::PxDim3), unsafe_offsetof(physx_PxSDFDesc_Pod, dims));
sg.add_field("physx_PxVec3_Pod meshLower", "meshLower", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxSDFDesc_Pod, meshLower));
sg.add_field("float spacing", "spacing", "f32", sizeof(float), unsafe_offsetof(physx_PxSDFDesc_Pod, spacing));
sg.add_field("uint32_t subgridSize", "subgridSize", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSDFDesc_Pod, subgridSize));
sg.add_field("int32_t bitsPerSubgridPixel", "bitsPerSubgridPixel", "PxSdfBitsPerSubgridPixel", sizeof(physx::PxSdfBitsPerSubgridPixel::Enum), unsafe_offsetof(physx_PxSDFDesc_Pod, bitsPerSubgridPixel));
sg.add_field("physx_PxDim3_Pod sdfSubgrids3DTexBlockDim", "sdfSubgrids3DTexBlockDim", "PxDim3", sizeof(physx::PxDim3), unsafe_offsetof(physx_PxSDFDesc_Pod, sdfSubgrids3DTexBlockDim));
sg.add_field("physx_PxBoundedData_Pod sdfSubgrids", "sdfSubgrids", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxSDFDesc_Pod, sdfSubgrids));
sg.add_field("physx_PxBoundedData_Pod sdfStartSlots", "sdfStartSlots", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxSDFDesc_Pod, sdfStartSlots));
sg.add_field("float subgridsMinSdfValue", "subgridsMinSdfValue", "f32", sizeof(float), unsafe_offsetof(physx_PxSDFDesc_Pod, subgridsMinSdfValue));
sg.add_field("float subgridsMaxSdfValue", "subgridsMaxSdfValue", "f32", sizeof(float), unsafe_offsetof(physx_PxSDFDesc_Pod, subgridsMaxSdfValue));
sg.add_field("physx_PxBounds3_Pod sdfBounds", "sdfBounds", "PxBounds3", sizeof(physx::PxBounds3), unsafe_offsetof(physx_PxSDFDesc_Pod, sdfBounds));
sg.add_field("float narrowBandThicknessRelativeToSdfBoundsDiagonal", "narrowBandThicknessRelativeToSdfBoundsDiagonal", "f32", sizeof(float), unsafe_offsetof(physx_PxSDFDesc_Pod, narrowBandThicknessRelativeToSdfBoundsDiagonal));
sg.add_field("uint32_t numThreadsForSdfConstruction", "numThreadsForSdfConstruction", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxSDFDesc_Pod, numThreadsForSdfConstruction));
sg.end_struct(sizeof(physx::PxSDFDesc));
}
};
physx_PxSDFDesc_Pod::dump_layout(sg);
struct physx_PxConvexMeshDesc_Pod: public physx::PxConvexMeshDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxConvexMeshDesc_Pod", "PxConvexMeshDesc");
sg.add_field("physx_PxBoundedData_Pod points", "points", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, points));
sg.add_field("physx_PxBoundedData_Pod polygons", "polygons", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, polygons));
sg.add_field("physx_PxBoundedData_Pod indices", "indices", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, indices));
sg.add_field("uint16_t flags", "flags", "PxConvexFlags", sizeof(physx::PxConvexFlags), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, flags));
sg.add_field("uint16_t vertexLimit", "vertexLimit", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, vertexLimit));
sg.add_field("uint16_t polygonLimit", "polygonLimit", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, polygonLimit));
sg.add_field("uint16_t quantizedCount", "quantizedCount", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, quantizedCount));
sg.add_field("physx_PxSDFDesc_Pod* sdfDesc", "sdfDesc", "*mut PxSDFDesc", sizeof(physx::PxSDFDesc*), unsafe_offsetof(physx_PxConvexMeshDesc_Pod, sdfDesc));
sg.end_struct(sizeof(physx::PxConvexMeshDesc));
}
};
physx_PxConvexMeshDesc_Pod::dump_layout(sg);
struct physx_PxTriangleMeshDesc_Pod: public physx::PxTriangleMeshDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTriangleMeshDesc_Pod", "PxTriangleMeshDesc");
sg.add_field("physx_PxBoundedData_Pod points", "points", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxTriangleMeshDesc_Pod, points));
sg.add_field("physx_PxBoundedData_Pod triangles", "triangles", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxTriangleMeshDesc_Pod, triangles));
sg.add_field("uint16_t flags", "flags", "PxMeshFlags", sizeof(physx::PxMeshFlags), unsafe_offsetof(physx_PxTriangleMeshDesc_Pod, flags));
sg.add_field("physx_PxSDFDesc_Pod* sdfDesc", "sdfDesc", "*mut PxSDFDesc", sizeof(physx::PxSDFDesc*), unsafe_offsetof(physx_PxTriangleMeshDesc_Pod, sdfDesc));
sg.end_struct(sizeof(physx::PxTriangleMeshDesc));
}
};
physx_PxTriangleMeshDesc_Pod::dump_layout(sg);
struct physx_PxTetrahedronMeshDesc_Pod: public physx::PxTetrahedronMeshDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTetrahedronMeshDesc_Pod", "PxTetrahedronMeshDesc");
sg.add_field("physx_PxBoundedData_Pod points", "points", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxTetrahedronMeshDesc_Pod, points));
sg.add_field("physx_PxBoundedData_Pod tetrahedrons", "tetrahedrons", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxTetrahedronMeshDesc_Pod, tetrahedrons));
sg.add_field("uint16_t flags", "flags", "PxMeshFlags", sizeof(physx::PxMeshFlags), unsafe_offsetof(physx_PxTetrahedronMeshDesc_Pod, flags));
sg.add_field("uint16_t tetsPerElement", "tetsPerElement", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxTetrahedronMeshDesc_Pod, tetsPerElement));
sg.end_struct(sizeof(physx::PxTetrahedronMeshDesc));
}
};
physx_PxTetrahedronMeshDesc_Pod::dump_layout(sg);
struct physx_PxSoftBodySimulationDataDesc_Pod: public physx::PxSoftBodySimulationDataDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSoftBodySimulationDataDesc_Pod", "PxSoftBodySimulationDataDesc");
sg.add_field("physx_PxBoundedData_Pod vertexToTet", "vertexToTet", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxSoftBodySimulationDataDesc_Pod, vertexToTet));
sg.end_struct(sizeof(physx::PxSoftBodySimulationDataDesc));
}
};
physx_PxSoftBodySimulationDataDesc_Pod::dump_layout(sg);
struct physx_PxBVH34MidphaseDesc_Pod: public physx::PxBVH34MidphaseDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBVH34MidphaseDesc_Pod", "PxBVH34MidphaseDesc");
sg.add_field("uint32_t numPrimsPerLeaf", "numPrimsPerLeaf", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBVH34MidphaseDesc_Pod, numPrimsPerLeaf));
sg.add_field("int32_t buildStrategy", "buildStrategy", "PxBVH34BuildStrategy", sizeof(physx::PxBVH34BuildStrategy::Enum), unsafe_offsetof(physx_PxBVH34MidphaseDesc_Pod, buildStrategy));
sg.add_field("bool quantized", "quantized", "bool", sizeof(bool), unsafe_offsetof(physx_PxBVH34MidphaseDesc_Pod, quantized));
sg.end_struct(sizeof(physx::PxBVH34MidphaseDesc));
}
};
physx_PxBVH34MidphaseDesc_Pod::dump_layout(sg);
struct physx_PxMidphaseDesc_Pod: public physx::PxMidphaseDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxMidphaseDesc_Pod", "PxMidphaseDesc");
sg.end_struct(sizeof(physx::PxMidphaseDesc));
}
};
physx_PxMidphaseDesc_Pod::dump_layout(sg);
struct physx_PxBVHDesc_Pod: public physx::PxBVHDesc {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBVHDesc_Pod", "PxBVHDesc");
sg.add_field("physx_PxBoundedData_Pod bounds", "bounds", "PxBoundedData", sizeof(physx::PxBoundedData), unsafe_offsetof(physx_PxBVHDesc_Pod, bounds));
sg.add_field("float enlargement", "enlargement", "f32", sizeof(float), unsafe_offsetof(physx_PxBVHDesc_Pod, enlargement));
sg.add_field("uint32_t numPrimsPerLeaf", "numPrimsPerLeaf", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxBVHDesc_Pod, numPrimsPerLeaf));
sg.add_field("int32_t buildStrategy", "buildStrategy", "PxBVHBuildStrategy", sizeof(physx::PxBVHBuildStrategy::Enum), unsafe_offsetof(physx_PxBVHDesc_Pod, buildStrategy));
sg.end_struct(sizeof(physx::PxBVHDesc));
}
};
physx_PxBVHDesc_Pod::dump_layout(sg);
struct physx_PxCookingParams_Pod: public physx::PxCookingParams {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxCookingParams_Pod", "PxCookingParams");
sg.add_field("float areaTestEpsilon", "areaTestEpsilon", "f32", sizeof(float), unsafe_offsetof(physx_PxCookingParams_Pod, areaTestEpsilon));
sg.add_field("float planeTolerance", "planeTolerance", "f32", sizeof(float), unsafe_offsetof(physx_PxCookingParams_Pod, planeTolerance));
sg.add_field("int32_t convexMeshCookingType", "convexMeshCookingType", "PxConvexMeshCookingType", sizeof(physx::PxConvexMeshCookingType::Enum), unsafe_offsetof(physx_PxCookingParams_Pod, convexMeshCookingType));
sg.add_field("bool suppressTriangleMeshRemapTable", "suppressTriangleMeshRemapTable", "bool", sizeof(bool), unsafe_offsetof(physx_PxCookingParams_Pod, suppressTriangleMeshRemapTable));
sg.add_field("bool buildTriangleAdjacencies", "buildTriangleAdjacencies", "bool", sizeof(bool), unsafe_offsetof(physx_PxCookingParams_Pod, buildTriangleAdjacencies));
sg.add_field("bool buildGPUData", "buildGPUData", "bool", sizeof(bool), unsafe_offsetof(physx_PxCookingParams_Pod, buildGPUData));
sg.add_field("physx_PxTolerancesScale_Pod scale", "scale", "PxTolerancesScale", sizeof(physx::PxTolerancesScale), unsafe_offsetof(physx_PxCookingParams_Pod, scale));
sg.add_field("uint32_t meshPreprocessParams", "meshPreprocessParams", "PxMeshPreprocessingFlags", sizeof(physx::PxMeshPreprocessingFlags), unsafe_offsetof(physx_PxCookingParams_Pod, meshPreprocessParams));
sg.add_field("float meshWeldTolerance", "meshWeldTolerance", "f32", sizeof(float), unsafe_offsetof(physx_PxCookingParams_Pod, meshWeldTolerance));
sg.add_field("physx_PxMidphaseDesc_Pod midphaseDesc", "midphaseDesc", "PxMidphaseDesc", sizeof(physx::PxMidphaseDesc), unsafe_offsetof(physx_PxCookingParams_Pod, midphaseDesc));
sg.add_field("uint32_t gaussMapLimit", "gaussMapLimit", "u32", sizeof(uint32_t), unsafe_offsetof(physx_PxCookingParams_Pod, gaussMapLimit));
sg.add_field("float maxWeightRatioInTet", "maxWeightRatioInTet", "f32", sizeof(float), unsafe_offsetof(physx_PxCookingParams_Pod, maxWeightRatioInTet));
sg.end_struct(sizeof(physx::PxCookingParams));
}
};
physx_PxCookingParams_Pod::dump_layout(sg);
struct physx_PxDefaultMemoryOutputStream_Pod: public physx::PxDefaultMemoryOutputStream {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDefaultMemoryOutputStream_Pod", "PxDefaultMemoryOutputStream");
sg.end_struct(sizeof(physx::PxDefaultMemoryOutputStream));
}
};
physx_PxDefaultMemoryOutputStream_Pod::dump_layout(sg);
struct physx_PxDefaultMemoryInputData_Pod: public physx::PxDefaultMemoryInputData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDefaultMemoryInputData_Pod", "PxDefaultMemoryInputData");
sg.end_struct(sizeof(physx::PxDefaultMemoryInputData));
}
};
physx_PxDefaultMemoryInputData_Pod::dump_layout(sg);
struct physx_PxDefaultFileOutputStream_Pod: public physx::PxDefaultFileOutputStream {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDefaultFileOutputStream_Pod", "PxDefaultFileOutputStream");
sg.end_struct(sizeof(physx::PxDefaultFileOutputStream));
}
};
physx_PxDefaultFileOutputStream_Pod::dump_layout(sg);
struct physx_PxDefaultFileInputData_Pod: public physx::PxDefaultFileInputData {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDefaultFileInputData_Pod", "PxDefaultFileInputData");
sg.end_struct(sizeof(physx::PxDefaultFileInputData));
}
};
physx_PxDefaultFileInputData_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxDefaultAllocator_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxJoint_Pod;\n");
sg.pass_thru("struct physx_PxRackAndPinionJoint_Pod;\n");
sg.pass_thru("struct physx_PxGearJoint_Pod;\n");
sg.pass_thru("struct physx_PxD6Joint_Pod;\n");
sg.pass_thru("struct physx_PxDistanceJoint_Pod;\n");
sg.pass_thru("struct physx_PxContactJoint_Pod;\n");
sg.pass_thru("struct physx_PxFixedJoint_Pod;\n");
sg.pass_thru("struct physx_PxPrismaticJoint_Pod;\n");
sg.pass_thru("struct physx_PxRevoluteJoint_Pod;\n");
sg.pass_thru("struct physx_PxSphericalJoint_Pod;\n");
struct physx_PxJoint_Pod: public physx::PxJoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxJoint_Pod", "PxJoint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxJoint_Pod, userData));
sg.end_struct(sizeof(physx::PxJoint));
}
};
physx_PxJoint_Pod::dump_layout(sg);
struct physx_PxSpring_Pod: public physx::PxSpring {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSpring_Pod", "PxSpring");
sg.add_field("float stiffness", "stiffness", "f32", sizeof(float), unsafe_offsetof(physx_PxSpring_Pod, stiffness));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxSpring_Pod, damping));
sg.end_struct(sizeof(physx::PxSpring));
}
};
physx_PxSpring_Pod::dump_layout(sg);
struct physx_PxDistanceJoint_Pod: public physx::PxDistanceJoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxDistanceJoint_Pod", "PxDistanceJoint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxDistanceJoint_Pod, userData));
sg.end_struct(sizeof(physx::PxDistanceJoint));
}
};
physx_PxDistanceJoint_Pod::dump_layout(sg);
struct physx_PxJacobianRow_Pod: public physx::PxJacobianRow {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxJacobianRow_Pod", "PxJacobianRow");
sg.add_field("physx_PxVec3_Pod linear0", "linear0", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxJacobianRow_Pod, linear0));
sg.add_field("physx_PxVec3_Pod linear1", "linear1", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxJacobianRow_Pod, linear1));
sg.add_field("physx_PxVec3_Pod angular0", "angular0", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxJacobianRow_Pod, angular0));
sg.add_field("physx_PxVec3_Pod angular1", "angular1", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxJacobianRow_Pod, angular1));
sg.end_struct(sizeof(physx::PxJacobianRow));
}
};
physx_PxJacobianRow_Pod::dump_layout(sg);
struct physx_PxContactJoint_Pod: public physx::PxContactJoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxContactJoint_Pod", "PxContactJoint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxContactJoint_Pod, userData));
sg.end_struct(sizeof(physx::PxContactJoint));
}
};
physx_PxContactJoint_Pod::dump_layout(sg);
struct physx_PxFixedJoint_Pod: public physx::PxFixedJoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxFixedJoint_Pod", "PxFixedJoint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxFixedJoint_Pod, userData));
sg.end_struct(sizeof(physx::PxFixedJoint));
}
};
physx_PxFixedJoint_Pod::dump_layout(sg);
struct physx_PxJointLimitParameters_Pod: public physx::PxJointLimitParameters {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxJointLimitParameters_Pod", "PxJointLimitParameters");
sg.add_field("float restitution", "restitution", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitParameters_Pod, restitution));
sg.add_field("float bounceThreshold", "bounceThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitParameters_Pod, bounceThreshold));
sg.add_field("float stiffness", "stiffness", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitParameters_Pod, stiffness));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitParameters_Pod, damping));
sg.add_field("float contactDistance_deprecated", "contactDistance_deprecated", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitParameters_Pod, contactDistance_deprecated));
sg.end_struct(sizeof(physx::PxJointLimitParameters));
}
};
physx_PxJointLimitParameters_Pod::dump_layout(sg);
struct physx_PxJointLinearLimit_Pod: public physx::PxJointLinearLimit {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxJointLinearLimit_Pod", "PxJointLinearLimit");
sg.add_field("float restitution", "restitution", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimit_Pod, restitution));
sg.add_field("float bounceThreshold", "bounceThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimit_Pod, bounceThreshold));
sg.add_field("float stiffness", "stiffness", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimit_Pod, stiffness));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimit_Pod, damping));
sg.add_field("float contactDistance_deprecated", "contactDistance_deprecated", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimit_Pod, contactDistance_deprecated));
sg.add_field("float value", "value", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimit_Pod, value));
sg.end_struct(sizeof(physx::PxJointLinearLimit));
}
};
physx_PxJointLinearLimit_Pod::dump_layout(sg);
struct physx_PxJointLinearLimitPair_Pod: public physx::PxJointLinearLimitPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxJointLinearLimitPair_Pod", "PxJointLinearLimitPair");
sg.add_field("float restitution", "restitution", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, restitution));
sg.add_field("float bounceThreshold", "bounceThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, bounceThreshold));
sg.add_field("float stiffness", "stiffness", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, stiffness));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, damping));
sg.add_field("float contactDistance_deprecated", "contactDistance_deprecated", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, contactDistance_deprecated));
sg.add_field("float upper", "upper", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, upper));
sg.add_field("float lower", "lower", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLinearLimitPair_Pod, lower));
sg.end_struct(sizeof(physx::PxJointLinearLimitPair));
}
};
physx_PxJointLinearLimitPair_Pod::dump_layout(sg);
struct physx_PxJointAngularLimitPair_Pod: public physx::PxJointAngularLimitPair {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxJointAngularLimitPair_Pod", "PxJointAngularLimitPair");
sg.add_field("float restitution", "restitution", "f32", sizeof(float), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, restitution));
sg.add_field("float bounceThreshold", "bounceThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, bounceThreshold));
sg.add_field("float stiffness", "stiffness", "f32", sizeof(float), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, stiffness));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, damping));
sg.add_field("float contactDistance_deprecated", "contactDistance_deprecated", "f32", sizeof(float), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, contactDistance_deprecated));
sg.add_field("float upper", "upper", "f32", sizeof(float), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, upper));
sg.add_field("float lower", "lower", "f32", sizeof(float), unsafe_offsetof(physx_PxJointAngularLimitPair_Pod, lower));
sg.end_struct(sizeof(physx::PxJointAngularLimitPair));
}
};
physx_PxJointAngularLimitPair_Pod::dump_layout(sg);
struct physx_PxJointLimitCone_Pod: public physx::PxJointLimitCone {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxJointLimitCone_Pod", "PxJointLimitCone");
sg.add_field("float restitution", "restitution", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitCone_Pod, restitution));
sg.add_field("float bounceThreshold", "bounceThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitCone_Pod, bounceThreshold));
sg.add_field("float stiffness", "stiffness", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitCone_Pod, stiffness));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitCone_Pod, damping));
sg.add_field("float contactDistance_deprecated", "contactDistance_deprecated", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitCone_Pod, contactDistance_deprecated));
sg.add_field("float yAngle", "yAngle", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitCone_Pod, yAngle));
sg.add_field("float zAngle", "zAngle", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitCone_Pod, zAngle));
sg.end_struct(sizeof(physx::PxJointLimitCone));
}
};
physx_PxJointLimitCone_Pod::dump_layout(sg);
struct physx_PxJointLimitPyramid_Pod: public physx::PxJointLimitPyramid {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxJointLimitPyramid_Pod", "PxJointLimitPyramid");
sg.add_field("float restitution", "restitution", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, restitution));
sg.add_field("float bounceThreshold", "bounceThreshold", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, bounceThreshold));
sg.add_field("float stiffness", "stiffness", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, stiffness));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, damping));
sg.add_field("float contactDistance_deprecated", "contactDistance_deprecated", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, contactDistance_deprecated));
sg.add_field("float yAngleMin", "yAngleMin", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, yAngleMin));
sg.add_field("float yAngleMax", "yAngleMax", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, yAngleMax));
sg.add_field("float zAngleMin", "zAngleMin", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, zAngleMin));
sg.add_field("float zAngleMax", "zAngleMax", "f32", sizeof(float), unsafe_offsetof(physx_PxJointLimitPyramid_Pod, zAngleMax));
sg.end_struct(sizeof(physx::PxJointLimitPyramid));
}
};
physx_PxJointLimitPyramid_Pod::dump_layout(sg);
struct physx_PxPrismaticJoint_Pod: public physx::PxPrismaticJoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxPrismaticJoint_Pod", "PxPrismaticJoint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxPrismaticJoint_Pod, userData));
sg.end_struct(sizeof(physx::PxPrismaticJoint));
}
};
physx_PxPrismaticJoint_Pod::dump_layout(sg);
struct physx_PxRevoluteJoint_Pod: public physx::PxRevoluteJoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRevoluteJoint_Pod", "PxRevoluteJoint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxRevoluteJoint_Pod, userData));
sg.end_struct(sizeof(physx::PxRevoluteJoint));
}
};
physx_PxRevoluteJoint_Pod::dump_layout(sg);
struct physx_PxSphericalJoint_Pod: public physx::PxSphericalJoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSphericalJoint_Pod", "PxSphericalJoint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxSphericalJoint_Pod, userData));
sg.end_struct(sizeof(physx::PxSphericalJoint));
}
};
physx_PxSphericalJoint_Pod::dump_layout(sg);
struct physx_PxD6JointDrive_Pod: public physx::PxD6JointDrive {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxD6JointDrive_Pod", "PxD6JointDrive");
sg.add_field("float stiffness", "stiffness", "f32", sizeof(float), unsafe_offsetof(physx_PxD6JointDrive_Pod, stiffness));
sg.add_field("float damping", "damping", "f32", sizeof(float), unsafe_offsetof(physx_PxD6JointDrive_Pod, damping));
sg.add_field("float forceLimit", "forceLimit", "f32", sizeof(float), unsafe_offsetof(physx_PxD6JointDrive_Pod, forceLimit));
sg.add_field("uint32_t flags", "flags", "PxD6JointDriveFlags", sizeof(physx::PxD6JointDriveFlags), unsafe_offsetof(physx_PxD6JointDrive_Pod, flags));
sg.end_struct(sizeof(physx::PxD6JointDrive));
}
};
physx_PxD6JointDrive_Pod::dump_layout(sg);
struct physx_PxD6Joint_Pod: public physx::PxD6Joint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxD6Joint_Pod", "PxD6Joint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxD6Joint_Pod, userData));
sg.end_struct(sizeof(physx::PxD6Joint));
}
};
physx_PxD6Joint_Pod::dump_layout(sg);
struct physx_PxGearJoint_Pod: public physx::PxGearJoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGearJoint_Pod", "PxGearJoint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxGearJoint_Pod, userData));
sg.end_struct(sizeof(physx::PxGearJoint));
}
};
physx_PxGearJoint_Pod::dump_layout(sg);
struct physx_PxRackAndPinionJoint_Pod: public physx::PxRackAndPinionJoint {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRackAndPinionJoint_Pod", "PxRackAndPinionJoint");
sg.add_field("void* userData", "userData", "*mut std::ffi::c_void", sizeof(void*), unsafe_offsetof(physx_PxRackAndPinionJoint_Pod, userData));
sg.end_struct(sizeof(physx::PxRackAndPinionJoint));
}
};
physx_PxRackAndPinionJoint_Pod::dump_layout(sg);
struct physx_PxGroupsMask_Pod: public physx::PxGroupsMask {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxGroupsMask_Pod", "PxGroupsMask");
sg.add_field("uint16_t bits0", "bits0", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxGroupsMask_Pod, bits0));
sg.add_field("uint16_t bits1", "bits1", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxGroupsMask_Pod, bits1));
sg.add_field("uint16_t bits2", "bits2", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxGroupsMask_Pod, bits2));
sg.add_field("uint16_t bits3", "bits3", "u16", sizeof(uint16_t), unsafe_offsetof(physx_PxGroupsMask_Pod, bits3));
sg.end_struct(sizeof(physx::PxGroupsMask));
}
};
physx_PxGroupsMask_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxDefaultErrorCallback_Pod {\n void* vtable_;\n};\n");
struct physx_PxRigidActorExt_Pod: public physx::PxRigidActorExt {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRigidActorExt_Pod", "PxRigidActorExt");
sg.end_struct(sizeof(physx::PxRigidActorExt));
}
};
physx_PxRigidActorExt_Pod::dump_layout(sg);
struct physx_PxMassProperties_Pod: public physx::PxMassProperties {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxMassProperties_Pod", "PxMassProperties");
sg.add_field("physx_PxMat33_Pod inertiaTensor", "inertiaTensor", "PxMat33", sizeof(physx::PxMat33), unsafe_offsetof(physx_PxMassProperties_Pod, inertiaTensor));
sg.add_field("physx_PxVec3_Pod centerOfMass", "centerOfMass", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxMassProperties_Pod, centerOfMass));
sg.add_field("float mass", "mass", "f32", sizeof(float), unsafe_offsetof(physx_PxMassProperties_Pod, mass));
sg.end_struct(sizeof(physx::PxMassProperties));
}
};
physx_PxMassProperties_Pod::dump_layout(sg);
struct physx_PxRigidBodyExt_Pod: public physx::PxRigidBodyExt {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRigidBodyExt_Pod", "PxRigidBodyExt");
sg.end_struct(sizeof(physx::PxRigidBodyExt));
}
};
physx_PxRigidBodyExt_Pod::dump_layout(sg);
struct physx_PxShapeExt_Pod: public physx::PxShapeExt {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxShapeExt_Pod", "PxShapeExt");
sg.end_struct(sizeof(physx::PxShapeExt));
}
};
physx_PxShapeExt_Pod::dump_layout(sg);
struct physx_PxMeshOverlapUtil_Pod: public physx::PxMeshOverlapUtil {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxMeshOverlapUtil_Pod", "PxMeshOverlapUtil");
sg.end_struct(sizeof(physx::PxMeshOverlapUtil));
}
};
physx_PxMeshOverlapUtil_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxBinaryConverter_Pod;\n");
struct physx_PxXmlMiscParameter_Pod: public physx::PxXmlMiscParameter {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxXmlMiscParameter_Pod", "PxXmlMiscParameter");
sg.add_field("physx_PxVec3_Pod upVector", "upVector", "PxVec3", sizeof(physx::PxVec3), unsafe_offsetof(physx_PxXmlMiscParameter_Pod, upVector));
sg.add_field("physx_PxTolerancesScale_Pod scale", "scale", "PxTolerancesScale", sizeof(physx::PxTolerancesScale), unsafe_offsetof(physx_PxXmlMiscParameter_Pod, scale));
sg.end_struct(sizeof(physx::PxXmlMiscParameter));
}
};
physx_PxXmlMiscParameter_Pod::dump_layout(sg);
struct physx_PxSerialization_Pod: public physx::PxSerialization {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSerialization_Pod", "PxSerialization");
sg.end_struct(sizeof(physx::PxSerialization));
}
};
physx_PxSerialization_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxDefaultCpuDispatcher_Pod {\n void* vtable_;\n};\n");
struct physx_PxStringTableExt_Pod: public physx::PxStringTableExt {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxStringTableExt_Pod", "PxStringTableExt");
sg.end_struct(sizeof(physx::PxStringTableExt));
}
};
physx_PxStringTableExt_Pod::dump_layout(sg);
struct physx_PxBroadPhaseExt_Pod: public physx::PxBroadPhaseExt {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxBroadPhaseExt_Pod", "PxBroadPhaseExt");
sg.end_struct(sizeof(physx::PxBroadPhaseExt));
}
};
physx_PxBroadPhaseExt_Pod::dump_layout(sg);
struct physx_PxSceneQueryExt_Pod: public physx::PxSceneQueryExt {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSceneQueryExt_Pod", "PxSceneQueryExt");
sg.end_struct(sizeof(physx::PxSceneQueryExt));
}
};
physx_PxSceneQueryExt_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxBatchQueryExt_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxCustomSceneQuerySystem_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxCustomSceneQuerySystemAdapter_Pod {\n void* vtable_;\n};\n");
struct physx_PxSamplingExt_Pod: public physx::PxSamplingExt {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxSamplingExt_Pod", "PxSamplingExt");
sg.end_struct(sizeof(physx::PxSamplingExt));
}
};
physx_PxSamplingExt_Pod::dump_layout(sg);
struct physx_PxPoissonSampler_Pod: public physx::PxPoissonSampler {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxPoissonSampler_Pod", "PxPoissonSampler");
sg.end_struct(sizeof(physx::PxPoissonSampler));
}
};
physx_PxPoissonSampler_Pod::dump_layout(sg);
struct physx_PxTriangleMeshPoissonSampler_Pod: public physx::PxTriangleMeshPoissonSampler {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTriangleMeshPoissonSampler_Pod", "PxTriangleMeshPoissonSampler");
sg.end_struct(sizeof(physx::PxTriangleMeshPoissonSampler));
}
};
physx_PxTriangleMeshPoissonSampler_Pod::dump_layout(sg);
struct physx_PxTetrahedronMeshExt_Pod: public physx::PxTetrahedronMeshExt {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxTetrahedronMeshExt_Pod", "PxTetrahedronMeshExt");
sg.end_struct(sizeof(physx::PxTetrahedronMeshExt));
}
};
physx_PxTetrahedronMeshExt_Pod::dump_layout(sg);
struct physx_PxRepXObject_Pod: public physx::PxRepXObject {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRepXObject_Pod", "PxRepXObject");
sg.add_field("char const* typeName", "typeName", "*const std::ffi::c_char", sizeof(char const*), unsafe_offsetof(physx_PxRepXObject_Pod, typeName));
sg.add_field("void const* serializable", "serializable", "*const std::ffi::c_void", sizeof(void const*), unsafe_offsetof(physx_PxRepXObject_Pod, serializable));
sg.add_field("uint64_t id", "id", "u64", sizeof(uint64_t), unsafe_offsetof(physx_PxRepXObject_Pod, id));
sg.end_struct(sizeof(physx::PxRepXObject));
}
};
physx_PxRepXObject_Pod::dump_layout(sg);
sg.pass_thru("struct physx_PxCooking_Pod;\n");
struct physx_PxRepXInstantiationArgs_Pod: public physx::PxRepXInstantiationArgs {
static void dump_layout(PodStructGen& sg) {
sg.begin_struct("physx_PxRepXInstantiationArgs_Pod", "PxRepXInstantiationArgs");
sg.add_field("physx_PxCooking_Pod* cooker", "cooker", "*mut PxCooking", sizeof(physx::PxCooking*), unsafe_offsetof(physx_PxRepXInstantiationArgs_Pod, cooker));
sg.add_field("physx_PxStringTable_Pod* stringTable", "stringTable", "*mut PxStringTable", sizeof(physx::PxStringTable*), unsafe_offsetof(physx_PxRepXInstantiationArgs_Pod, stringTable));
sg.end_struct(sizeof(physx::PxRepXInstantiationArgs));
}
};
physx_PxRepXInstantiationArgs_Pod::dump_layout(sg);
sg.pass_thru("struct physx_XmlMemoryAllocator_Pod;\n");
sg.pass_thru("struct physx_XmlWriter_Pod;\n");
sg.pass_thru("struct physx_XmlReader_Pod;\n");
sg.pass_thru("struct physx_MemoryBuffer_Pod;\n");
sg.pass_thru("struct physx_PxRepXSerializer_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxVehicleWheels4SimData_Pod;\n");
sg.pass_thru("struct physx_PxVehicleWheels4DynData_Pod;\n");
sg.pass_thru("struct physx_PxVehicleTireForceCalculator_Pod;\n");
sg.pass_thru("struct physx_PxVehicleDrivableSurfaceToTireFrictionPairs_Pod;\n");
sg.pass_thru("struct physx_PxVehicleTelemetryData_Pod;\n");
sg.pass_thru("struct physx_PxPvdTransport_Pod;\n");
sg.pass_thru("struct physx_PxPvd_Pod {\n void* vtable_;\n};\n");
sg.pass_thru("struct physx_PxPvdTransport_Pod {\n void* vtable_;\n};\n");
sg.finish();
}