1#[derive(Clone, Copy)]
2#[cfg_attr(feature = "debug-structs", derive(Debug))]
3#[repr(C)]
4pub struct PxAllocator {
5 pub structgen_pad0: [u8; 1],
6}
7#[derive(Clone, Copy)]
8#[cfg_attr(feature = "debug-structs", derive(Debug))]
9#[repr(C)]
10pub struct PxRawAllocator {
11 pub structgen_pad0: [u8; 1],
12}
13#[derive(Clone, Copy)]
14#[cfg_attr(feature = "debug-structs", derive(Debug))]
15#[repr(C)]
16pub struct PxVirtualAllocator {
17 pub structgen_pad0: [u8; 16],
18}
19#[derive(Clone, Copy)]
20#[cfg_attr(feature = "debug-structs", derive(Debug))]
21#[repr(C)]
22pub struct PxUserAllocated {
23 pub structgen_pad0: [u8; 1],
24}
25#[derive(Clone, Copy)]
26#[cfg_attr(feature = "debug-structs", derive(Debug))]
27#[repr(C)]
28pub struct PxTempAllocator {
29 pub structgen_pad0: [u8; 1],
30}
31#[derive(Clone, Copy)]
32#[cfg_attr(feature = "debug-structs", derive(Debug))]
33#[repr(C)]
34pub struct PxBitAndByte {
35 pub structgen_pad0: [u8; 1],
36}
37#[derive(Clone, Copy)]
38#[cfg_attr(feature = "debug-structs", derive(Debug))]
39#[repr(C)]
40pub struct PxBitMap {
41 pub structgen_pad0: [u8; 16],
42}
43#[derive(Clone, Copy)]
44#[cfg_attr(feature = "debug-structs", derive(Debug))]
45#[repr(C)]
46pub struct PxVec3 {
47 pub x: f32,
48 pub y: f32,
49 pub z: f32,
50}
51#[derive(Clone, Copy)]
52#[cfg_attr(feature = "debug-structs", derive(Debug))]
53#[repr(C)]
54pub struct PxVec3Padded {
55 pub x: f32,
56 pub y: f32,
57 pub z: f32,
58 pub padding: u32,
59}
60#[derive(Clone, Copy)]
61#[cfg_attr(feature = "debug-structs", derive(Debug))]
62#[repr(C)]
63pub struct PxQuat {
64 pub x: f32,
65 pub y: f32,
66 pub z: f32,
67 pub w: f32,
68}
69#[derive(Clone, Copy)]
70#[cfg_attr(feature = "debug-structs", derive(Debug))]
71#[repr(C)]
72pub struct PxTransform {
73 pub q: PxQuat,
74 pub p: PxVec3,
75}
76#[derive(Clone, Copy)]
77#[cfg_attr(feature = "debug-structs", derive(Debug))]
78#[repr(C)]
79pub struct PxTransformPadded {
80 pub transform: PxTransform,
81 pub padding: u32,
82}
83#[derive(Clone, Copy)]
84#[cfg_attr(feature = "debug-structs", derive(Debug))]
85#[repr(C)]
86pub struct PxMat33 {
87 pub column0: PxVec3,
88 pub column1: PxVec3,
89 pub column2: PxVec3,
90}
91#[derive(Clone, Copy)]
92#[cfg_attr(feature = "debug-structs", derive(Debug))]
93#[repr(C)]
94pub struct PxBounds3 {
95 pub minimum: PxVec3,
96 pub maximum: PxVec3,
97}
98#[derive(Clone, Copy)]
99#[cfg_attr(feature = "debug-structs", derive(Debug))]
100#[repr(C)]
101pub struct PxBroadcastingAllocator {
102 pub structgen_pad0: [u8; 176],
103}
104#[derive(Clone, Copy)]
105#[cfg_attr(feature = "debug-structs", derive(Debug))]
106#[repr(C)]
107pub struct PxBroadcastingErrorCallback {
108 pub structgen_pad0: [u8; 160],
109}
110#[derive(Clone, Copy)]
111#[cfg_attr(feature = "debug-structs", derive(Debug))]
112#[repr(C)]
113pub struct PxVec4 {
114 pub x: f32,
115 pub y: f32,
116 pub z: f32,
117 pub w: f32,
118}
119#[derive(Clone, Copy)]
120#[cfg_attr(feature = "debug-structs", derive(Debug))]
121#[repr(C)]
122pub struct PxMat44 {
123 pub column0: PxVec4,
124 pub column1: PxVec4,
125 pub column2: PxVec4,
126 pub column3: PxVec4,
127}
128#[derive(Clone, Copy)]
129#[cfg_attr(feature = "debug-structs", derive(Debug))]
130#[repr(C)]
131pub struct PxPlane {
132 pub n: PxVec3,
133 pub d: f32,
134}
135#[derive(Clone, Copy)]
136#[cfg_attr(feature = "debug-structs", derive(Debug))]
137#[repr(C)]
138pub struct Interpolation {
139 pub structgen_pad0: [u8; 1],
140}
141#[derive(Clone, Copy)]
142#[cfg_attr(feature = "debug-structs", derive(Debug))]
143#[repr(C)]
144pub struct PxMutexImpl {
145 pub structgen_pad0: [u8; 1],
146}
147#[derive(Clone, Copy)]
148#[cfg_attr(feature = "debug-structs", derive(Debug))]
149#[repr(C)]
150pub struct PxReadWriteLock {
151 pub structgen_pad0: [u8; 8],
152}
153#[derive(Clone, Copy)]
154#[cfg_attr(feature = "debug-structs", derive(Debug))]
155#[repr(C)]
156pub struct PxProfileScoped {
157 pub mCallback: *mut PxProfilerCallback,
158 pub mEventName: *const std::ffi::c_char,
159 pub mProfilerData: *mut std::ffi::c_void,
160 pub mContextId: u64,
161 pub mDetached: bool,
162 pub structgen_pad0: [u8; 7],
163}
164#[derive(Clone, Copy)]
165#[cfg_attr(feature = "debug-structs", derive(Debug))]
166#[repr(C)]
167pub struct PxSListEntry {
168 pub structgen_pad0: [u8; 16],
169}
170#[derive(Clone, Copy)]
171#[cfg_attr(feature = "debug-structs", derive(Debug))]
172#[repr(C)]
173pub struct PxSListImpl {
174 pub structgen_pad0: [u8; 1],
175}
176#[derive(Clone, Copy)]
177#[cfg_attr(feature = "debug-structs", derive(Debug))]
178#[repr(C)]
179pub struct PxSyncImpl {
180 pub structgen_pad0: [u8; 1],
181}
182#[derive(Clone, Copy)]
183#[cfg_attr(feature = "debug-structs", derive(Debug))]
184#[repr(C)]
185pub struct PxCounterFrequencyToTensOfNanos {
186 pub mNumerator: u64,
187 pub mDenominator: u64,
188}
189#[derive(Clone, Copy)]
190#[cfg_attr(feature = "debug-structs", derive(Debug))]
191#[repr(C)]
192pub struct PxTime {
193 pub structgen_pad0: [u8; 8],
194}
195#[derive(Clone, Copy)]
196#[cfg_attr(feature = "debug-structs", derive(Debug))]
197#[repr(C)]
198pub struct PxVec2 {
199 pub x: f32,
200 pub y: f32,
201}
202#[derive(Clone, Copy)]
203#[cfg_attr(feature = "debug-structs", derive(Debug))]
204#[repr(C)]
205pub struct PxStridedData {
206 pub stride: u32,
207 pub structgen_pad0: [u8; 4],
208 pub data: *const std::ffi::c_void,
209}
210#[derive(Clone, Copy)]
211#[cfg_attr(feature = "debug-structs", derive(Debug))]
212#[repr(C)]
213pub struct PxBoundedData {
214 pub stride: u32,
215 pub structgen_pad0: [u8; 4],
216 pub data: *const std::ffi::c_void,
217 pub count: u32,
218 pub structgen_pad1: [u8; 4],
219}
220#[derive(Clone, Copy)]
221#[cfg_attr(feature = "debug-structs", derive(Debug))]
222#[repr(C)]
223pub struct PxDebugPoint {
224 pub pos: PxVec3,
225 pub color: u32,
226}
227#[derive(Clone, Copy)]
228#[cfg_attr(feature = "debug-structs", derive(Debug))]
229#[repr(C)]
230pub struct PxDebugLine {
231 pub pos0: PxVec3,
232 pub color0: u32,
233 pub pos1: PxVec3,
234 pub color1: u32,
235}
236#[derive(Clone, Copy)]
237#[cfg_attr(feature = "debug-structs", derive(Debug))]
238#[repr(C)]
239pub struct PxDebugTriangle {
240 pub pos0: PxVec3,
241 pub color0: u32,
242 pub pos1: PxVec3,
243 pub color1: u32,
244 pub pos2: PxVec3,
245 pub color2: u32,
246}
247#[derive(Clone, Copy)]
248#[cfg_attr(feature = "debug-structs", derive(Debug))]
249#[repr(C)]
250pub struct PxDebugText {
251 pub position: PxVec3,
252 pub size: f32,
253 pub color: u32,
254 pub structgen_pad0: [u8; 4],
255 pub string: *const std::ffi::c_char,
256}
257#[derive(Clone, Copy)]
258#[cfg_attr(feature = "debug-structs", derive(Debug))]
259#[repr(C)]
260pub struct PxDeserializationContext {
261 pub structgen_pad0: [u8; 16],
262}
263#[derive(Clone, Copy)]
264#[cfg_attr(feature = "debug-structs", derive(Debug))]
265#[repr(C)]
266pub struct PxBase {
267 pub structgen_pad0: [u8; 16],
268}
269#[derive(Clone, Copy)]
270#[cfg_attr(feature = "debug-structs", derive(Debug))]
271#[repr(C)]
272pub struct PxRefCounted {
273 pub structgen_pad0: [u8; 16],
274}
275#[derive(Clone, Copy)]
276#[cfg_attr(feature = "debug-structs", derive(Debug))]
277#[repr(C)]
278pub struct PxTolerancesScale {
279 pub length: f32,
280 pub speed: f32,
281}
282#[derive(Clone, Copy)]
283#[cfg_attr(feature = "debug-structs", derive(Debug))]
284#[repr(C)]
285pub struct PxMetaDataEntry {
286 pub type_: *const std::ffi::c_char,
287 pub name: *const std::ffi::c_char,
288 pub offset: u32,
289 pub size: u32,
290 pub count: u32,
291 pub offsetSize: u32,
292 pub flags: u32,
293 pub alignment: u32,
294}
295#[derive(Clone, Copy)]
296#[cfg_attr(feature = "debug-structs", derive(Debug))]
297#[repr(C)]
298pub struct PxBaseTask {
299 pub structgen_pad0: [u8; 24],
300}
301#[derive(Clone, Copy)]
302#[cfg_attr(feature = "debug-structs", derive(Debug))]
303#[repr(C)]
304pub struct PxTask {
305 pub structgen_pad0: [u8; 32],
306}
307#[derive(Clone, Copy)]
308#[cfg_attr(feature = "debug-structs", derive(Debug))]
309#[repr(C)]
310pub struct PxLightCpuTask {
311 pub structgen_pad0: [u8; 40],
312}
313#[derive(Clone, Copy)]
314#[cfg_attr(feature = "debug-structs", derive(Debug))]
315#[repr(C)]
316pub struct PxGeometry {
317 pub structgen_pad0: [u8; 4],
318 pub mTypePadding: f32,
319}
320#[derive(Clone, Copy)]
321#[cfg_attr(feature = "debug-structs", derive(Debug))]
322#[repr(C)]
323pub struct PxBoxGeometry {
324 pub structgen_pad0: [u8; 4],
325 pub mTypePadding: f32,
326 pub halfExtents: PxVec3,
327}
328#[derive(Clone, Copy)]
329#[cfg_attr(feature = "debug-structs", derive(Debug))]
330#[repr(C)]
331pub struct PxBVH {
332 pub structgen_pad0: [u8; 16],
333}
334#[derive(Clone, Copy)]
335#[cfg_attr(feature = "debug-structs", derive(Debug))]
336#[repr(C)]
337pub struct PxCapsuleGeometry {
338 pub structgen_pad0: [u8; 4],
339 pub mTypePadding: f32,
340 pub radius: f32,
341 pub halfHeight: f32,
342}
343#[derive(Clone, Copy)]
344#[cfg_attr(feature = "debug-structs", derive(Debug))]
345#[repr(C)]
346pub struct PxHullPolygon {
347 pub mPlane: [f32; 4],
348 pub mNbVerts: u16,
349 pub mIndexBase: u16,
350}
351#[derive(Clone, Copy)]
352#[cfg_attr(feature = "debug-structs", derive(Debug))]
353#[repr(C)]
354pub struct PxConvexMesh {
355 pub structgen_pad0: [u8; 16],
356}
357#[derive(Clone, Copy)]
358#[cfg_attr(feature = "debug-structs", derive(Debug))]
359#[repr(C)]
360pub struct PxMeshScale {
361 pub scale: PxVec3,
362 pub rotation: PxQuat,
363}
364#[derive(Clone, Copy)]
365#[cfg_attr(feature = "debug-structs", derive(Debug))]
366#[repr(C)]
367pub struct PxConvexMeshGeometry {
368 pub structgen_pad0: [u8; 4],
369 pub mTypePadding: f32,
370 pub scale: PxMeshScale,
371 pub structgen_pad1: [u8; 4],
372 pub convexMesh: *mut PxConvexMesh,
373 pub meshFlags: PxConvexMeshGeometryFlags,
374 pub structgen_pad2: [u8; 7],
375}
376#[derive(Clone, Copy)]
377#[cfg_attr(feature = "debug-structs", derive(Debug))]
378#[repr(C)]
379pub struct PxSphereGeometry {
380 pub structgen_pad0: [u8; 4],
381 pub mTypePadding: f32,
382 pub radius: f32,
383}
384#[derive(Clone, Copy)]
385#[cfg_attr(feature = "debug-structs", derive(Debug))]
386#[repr(C)]
387pub struct PxPlaneGeometry {
388 pub structgen_pad0: [u8; 4],
389 pub mTypePadding: f32,
390}
391#[derive(Clone, Copy)]
392#[cfg_attr(feature = "debug-structs", derive(Debug))]
393#[repr(C)]
394pub struct PxTriangleMeshGeometry {
395 pub structgen_pad0: [u8; 4],
396 pub mTypePadding: f32,
397 pub scale: PxMeshScale,
398 pub meshFlags: PxMeshGeometryFlags,
399 pub structgen_pad1: [u8; 3],
400 pub triangleMesh: *mut PxTriangleMesh,
401}
402#[derive(Clone, Copy)]
403#[cfg_attr(feature = "debug-structs", derive(Debug))]
404#[repr(C)]
405pub struct PxHeightFieldGeometry {
406 pub structgen_pad0: [u8; 4],
407 pub mTypePadding: f32,
408 pub heightField: *mut PxHeightField,
409 pub heightScale: f32,
410 pub rowScale: f32,
411 pub columnScale: f32,
412 pub heightFieldFlags: PxMeshGeometryFlags,
413 pub structgen_pad1: [u8; 3],
414}
415#[derive(Clone, Copy)]
416#[cfg_attr(feature = "debug-structs", derive(Debug))]
417#[repr(C)]
418pub struct PxParticleSystemGeometry {
419 pub structgen_pad0: [u8; 4],
420 pub mTypePadding: f32,
421 pub mSolverType: PxParticleSolverType,
422}
423#[derive(Clone, Copy)]
424#[cfg_attr(feature = "debug-structs", derive(Debug))]
425#[repr(C)]
426pub struct PxHairSystemGeometry {
427 pub structgen_pad0: [u8; 4],
428 pub mTypePadding: f32,
429}
430#[derive(Clone, Copy)]
431#[cfg_attr(feature = "debug-structs", derive(Debug))]
432#[repr(C)]
433pub struct PxTetrahedronMeshGeometry {
434 pub structgen_pad0: [u8; 4],
435 pub mTypePadding: f32,
436 pub tetrahedronMesh: *mut PxTetrahedronMesh,
437}
438#[derive(Clone, Copy)]
439#[cfg_attr(feature = "debug-structs", derive(Debug))]
440#[repr(C)]
441pub struct PxQueryHit {
442 pub faceIndex: u32,
443}
444#[derive(Clone, Copy)]
445#[cfg_attr(feature = "debug-structs", derive(Debug))]
446#[repr(C)]
447pub struct PxLocationHit {
448 pub faceIndex: u32,
449 pub flags: PxHitFlags,
450 pub structgen_pad0: [u8; 2],
451 pub position: PxVec3,
452 pub normal: PxVec3,
453 pub distance: f32,
454}
455#[derive(Clone, Copy)]
456#[cfg_attr(feature = "debug-structs", derive(Debug))]
457#[repr(C)]
458pub struct PxGeomRaycastHit {
459 pub faceIndex: u32,
460 pub flags: PxHitFlags,
461 pub structgen_pad0: [u8; 2],
462 pub position: PxVec3,
463 pub normal: PxVec3,
464 pub distance: f32,
465 pub u: f32,
466 pub v: f32,
467}
468#[derive(Clone, Copy)]
469#[cfg_attr(feature = "debug-structs", derive(Debug))]
470#[repr(C)]
471pub struct PxGeomOverlapHit {
472 pub faceIndex: u32,
473}
474#[derive(Clone, Copy)]
475#[cfg_attr(feature = "debug-structs", derive(Debug))]
476#[repr(C)]
477pub struct PxGeomSweepHit {
478 pub faceIndex: u32,
479 pub flags: PxHitFlags,
480 pub structgen_pad0: [u8; 2],
481 pub position: PxVec3,
482 pub normal: PxVec3,
483 pub distance: f32,
484}
485#[derive(Clone, Copy)]
486#[cfg_attr(feature = "debug-structs", derive(Debug))]
487#[repr(C)]
488pub struct PxGeomIndexPair {
489 pub id0: u32,
490 pub id1: u32,
491}
492#[derive(Clone, Copy)]
493#[cfg_attr(feature = "debug-structs", derive(Debug))]
494#[repr(C)]
495pub struct PxQueryThreadContext {
496 pub structgen_pad0: [u8; 1],
497}
498#[derive(Clone, Copy)]
499#[cfg_attr(feature = "debug-structs", derive(Debug))]
500#[repr(C)]
501pub struct PxCustomGeometryType {
502 pub structgen_pad0: [u8; 4],
503}
504#[derive(Clone, Copy)]
505#[cfg_attr(feature = "debug-structs", derive(Debug))]
506#[repr(C)]
507pub struct PxCustomGeometry {
508 pub structgen_pad0: [u8; 4],
509 pub mTypePadding: f32,
510 pub callbacks: *mut PxCustomGeometryCallbacks,
511}
512#[derive(Clone, Copy)]
513#[cfg_attr(feature = "debug-structs", derive(Debug))]
514#[repr(C)]
515pub struct PxGeometryHolder {
516 pub structgen_pad0: [u8; 56],
517}
518#[derive(Clone, Copy)]
519#[cfg_attr(feature = "debug-structs", derive(Debug))]
520#[repr(C)]
521pub struct PxGeometryQuery {
522 pub structgen_pad0: [u8; 1],
523}
524#[derive(Clone, Copy)]
525#[cfg_attr(feature = "debug-structs", derive(Debug))]
526#[repr(C)]
527pub struct PxHeightFieldSample {
528 pub height: i16,
529 pub materialIndex0: PxBitAndByte,
530 pub materialIndex1: PxBitAndByte,
531}
532#[derive(Clone, Copy)]
533#[cfg_attr(feature = "debug-structs", derive(Debug))]
534#[repr(C)]
535pub struct PxHeightField {
536 pub structgen_pad0: [u8; 16],
537}
538#[derive(Clone, Copy)]
539#[cfg_attr(feature = "debug-structs", derive(Debug))]
540#[repr(C)]
541pub struct PxHeightFieldDesc {
542 pub nbRows: u32,
543 pub nbColumns: u32,
544 pub format: PxHeightFieldFormat,
545 pub structgen_pad0: [u8; 4],
546 pub samples: PxStridedData,
547 pub convexEdgeThreshold: f32,
548 pub flags: PxHeightFieldFlags,
549 pub structgen_pad1: [u8; 2],
550}
551#[derive(Clone, Copy)]
552#[cfg_attr(feature = "debug-structs", derive(Debug))]
553#[repr(C)]
554pub struct PxMeshQuery {
555 pub structgen_pad0: [u8; 1],
556}
557#[derive(Clone, Copy)]
558#[cfg_attr(feature = "debug-structs", derive(Debug))]
559#[repr(C)]
560pub struct PxSimpleTriangleMesh {
561 pub points: PxBoundedData,
562 pub triangles: PxBoundedData,
563 pub flags: PxMeshFlags,
564 pub structgen_pad0: [u8; 6],
565}
566#[derive(Clone, Copy)]
567#[cfg_attr(feature = "debug-structs", derive(Debug))]
568#[repr(C)]
569pub struct PxTriangle {
570 pub verts: [PxVec3; 3],
571}
572#[derive(Clone, Copy)]
573#[cfg_attr(feature = "debug-structs", derive(Debug))]
574#[repr(C)]
575pub struct PxTrianglePadded {
576 pub verts: [PxVec3; 3],
577 pub padding: u32,
578}
579#[derive(Clone, Copy)]
580#[cfg_attr(feature = "debug-structs", derive(Debug))]
581#[repr(C)]
582pub struct PxTriangleMesh {
583 pub structgen_pad0: [u8; 16],
584}
585#[derive(Clone, Copy)]
586#[cfg_attr(feature = "debug-structs", derive(Debug))]
587#[repr(C)]
588pub struct PxBVH34TriangleMesh {
589 pub structgen_pad0: [u8; 16],
590}
591#[derive(Clone, Copy)]
592#[cfg_attr(feature = "debug-structs", derive(Debug))]
593#[repr(C)]
594pub struct PxTetrahedron {
595 pub verts: [PxVec3; 4],
596}
597#[derive(Clone, Copy)]
598#[cfg_attr(feature = "debug-structs", derive(Debug))]
599#[repr(C)]
600pub struct PxSoftBodyAuxData {
601 pub structgen_pad0: [u8; 16],
602}
603#[derive(Clone, Copy)]
604#[cfg_attr(feature = "debug-structs", derive(Debug))]
605#[repr(C)]
606pub struct PxTetrahedronMesh {
607 pub structgen_pad0: [u8; 16],
608}
609#[derive(Clone, Copy)]
610#[cfg_attr(feature = "debug-structs", derive(Debug))]
611#[repr(C)]
612pub struct PxSoftBodyMesh {
613 pub structgen_pad0: [u8; 16],
614}
615#[derive(Clone, Copy)]
616#[cfg_attr(feature = "debug-structs", derive(Debug))]
617#[repr(C)]
618pub struct PxCollisionMeshMappingData {
619 pub structgen_pad0: [u8; 8],
620}
621#[derive(Clone, Copy)]
622#[cfg_attr(feature = "debug-structs", derive(Debug))]
623#[repr(C)]
624pub struct PxSoftBodyCollisionData {
625 pub structgen_pad0: [u8; 1],
626}
627#[derive(Clone, Copy)]
628#[cfg_attr(feature = "debug-structs", derive(Debug))]
629#[repr(C)]
630pub struct PxTetrahedronMeshData {
631 pub structgen_pad0: [u8; 1],
632}
633#[derive(Clone, Copy)]
634#[cfg_attr(feature = "debug-structs", derive(Debug))]
635#[repr(C)]
636pub struct PxSoftBodySimulationData {
637 pub structgen_pad0: [u8; 1],
638}
639#[derive(Clone, Copy)]
640#[cfg_attr(feature = "debug-structs", derive(Debug))]
641#[repr(C)]
642pub struct PxCollisionTetrahedronMeshData {
643 pub structgen_pad0: [u8; 8],
644}
645#[derive(Clone, Copy)]
646#[cfg_attr(feature = "debug-structs", derive(Debug))]
647#[repr(C)]
648pub struct PxSimulationTetrahedronMeshData {
649 pub structgen_pad0: [u8; 8],
650}
651#[derive(Clone, Copy)]
652#[cfg_attr(feature = "debug-structs", derive(Debug))]
653#[repr(C)]
654pub struct PxActor {
655 pub structgen_pad0: [u8; 16],
656 pub userData: *mut std::ffi::c_void,
657}
658#[derive(Clone, Copy)]
659#[cfg_attr(feature = "debug-structs", derive(Debug))]
660#[repr(C)]
661pub struct PxAggregate {
662 pub structgen_pad0: [u8; 16],
663 pub userData: *mut std::ffi::c_void,
664}
665#[derive(Clone, Copy)]
666#[cfg_attr(feature = "debug-structs", derive(Debug))]
667#[repr(C)]
668pub struct PxSpringModifiers {
669 pub stiffness: f32,
670 pub damping: f32,
671 pub structgen_pad0: [u8; 8],
672}
673#[derive(Clone, Copy)]
674#[cfg_attr(feature = "debug-structs", derive(Debug))]
675#[repr(C)]
676pub struct PxRestitutionModifiers {
677 pub restitution: f32,
678 pub velocityThreshold: f32,
679 pub structgen_pad0: [u8; 8],
680}
681#[derive(Clone, Copy)]
682#[cfg_attr(feature = "debug-structs", derive(Debug))]
683#[repr(C)]
684pub struct Px1DConstraint {
685 pub linear0: PxVec3,
686 pub geometricError: f32,
687 pub angular0: PxVec3,
688 pub velocityTarget: f32,
689 pub linear1: PxVec3,
690 pub minImpulse: f32,
691 pub angular1: PxVec3,
692 pub maxImpulse: f32,
693 pub mods: Px1DConstraintMods,
694 pub forInternalUse: f32,
695 pub flags: u16,
696 pub solveHint: u16,
697 pub structgen_pad0: [u8; 8],
698}
699#[derive(Clone, Copy)]
700#[cfg_attr(feature = "debug-structs", derive(Debug))]
701#[repr(C)]
702pub struct PxConstraintInvMassScale {
703 pub linear0: f32,
704 pub angular0: f32,
705 pub linear1: f32,
706 pub angular1: f32,
707}
708#[derive(Clone, Copy)]
709#[cfg_attr(feature = "debug-structs", derive(Debug))]
710#[repr(C)]
711pub struct PxContactPoint {
712 pub normal: PxVec3,
713 pub separation: f32,
714 pub point: PxVec3,
715 pub maxImpulse: f32,
716 pub targetVel: PxVec3,
717 pub staticFriction: f32,
718 pub materialFlags: u8,
719 pub structgen_pad0: [u8; 3],
720 pub internalFaceIndex1: u32,
721 pub dynamicFriction: f32,
722 pub restitution: f32,
723 pub damping: f32,
724 pub structgen_pad1: [u8; 12],
725}
726#[derive(Clone, Copy)]
727#[cfg_attr(feature = "debug-structs", derive(Debug))]
728#[repr(C)]
729pub struct PxSolverBody {
730 pub linearVelocity: PxVec3,
731 pub maxSolverNormalProgress: u16,
732 pub maxSolverFrictionProgress: u16,
733 pub angularState: PxVec3,
734 pub solverProgress: u32,
735}
736#[derive(Clone, Copy)]
737#[cfg_attr(feature = "debug-structs", derive(Debug))]
738#[repr(C)]
739pub struct PxSolverBodyData {
740 pub linearVelocity: PxVec3,
741 pub invMass: f32,
742 pub angularVelocity: PxVec3,
743 pub reportThreshold: f32,
744 pub sqrtInvInertia: PxMat33,
745 pub penBiasClamp: f32,
746 pub nodeIndex: u32,
747 pub maxContactImpulse: f32,
748 pub body2World: PxTransform,
749 pub pad: u16,
750 pub structgen_pad0: [u8; 2],
751}
752#[derive(Clone, Copy)]
753#[cfg_attr(feature = "debug-structs", derive(Debug))]
754#[repr(C)]
755pub struct PxConstraintBatchHeader {
756 pub startIndex: u32,
757 pub stride: u16,
758 pub constraintType: u16,
759}
760#[derive(Clone, Copy)]
761#[cfg_attr(feature = "debug-structs", derive(Debug))]
762#[repr(C)]
763pub struct PxSolverConstraintDesc {
764 pub structgen_pad0: [u8; 16],
765 pub bodyADataIndex: u32,
766 pub bodyBDataIndex: u32,
767 pub linkIndexA: u32,
768 pub linkIndexB: u32,
769 pub constraint: *mut u8,
770 pub writeBack: *mut std::ffi::c_void,
771 pub progressA: u16,
772 pub progressB: u16,
773 pub constraintLengthOver16: u16,
774 pub padding: [u8; 10],
775}
776#[derive(Clone, Copy)]
777#[cfg_attr(feature = "debug-structs", derive(Debug))]
778#[repr(C)]
779pub struct PxSolverConstraintPrepDescBase {
780 pub invMassScales: PxConstraintInvMassScale,
781 pub desc: *mut PxSolverConstraintDesc,
782 pub body0: *const PxSolverBody,
783 pub body1: *const PxSolverBody,
784 pub data0: *const PxSolverBodyData,
785 pub data1: *const PxSolverBodyData,
786 pub bodyFrame0: PxTransform,
787 pub bodyFrame1: PxTransform,
788 pub bodyState0: BodyState,
789 pub bodyState1: BodyState,
790 pub structgen_pad0: [u8; 8],
791}
792#[derive(Clone, Copy)]
793#[cfg_attr(feature = "debug-structs", derive(Debug))]
794#[repr(C)]
795pub struct PxSolverConstraintPrepDesc {
796 pub invMassScales: PxConstraintInvMassScale,
797 pub desc: *mut PxSolverConstraintDesc,
798 pub body0: *const PxSolverBody,
799 pub body1: *const PxSolverBody,
800 pub data0: *const PxSolverBodyData,
801 pub data1: *const PxSolverBodyData,
802 pub bodyFrame0: PxTransform,
803 pub bodyFrame1: PxTransform,
804 pub bodyState0: BodyState,
805 pub bodyState1: BodyState,
806 pub structgen_pad0: [u8; 8],
807 pub rows: *mut Px1DConstraint,
808 pub numRows: u32,
809 pub linBreakForce: f32,
810 pub angBreakForce: f32,
811 pub minResponseThreshold: f32,
812 pub writeback: *mut std::ffi::c_void,
813 pub disablePreprocessing: bool,
814 pub improvedSlerp: bool,
815 pub driveLimitsAreForces: bool,
816 pub extendedLimits: bool,
817 pub disableConstraint: bool,
818 pub structgen_pad1: [u8; 3],
819 pub body0WorldOffset: PxVec3Padded,
820 pub structgen_pad2: [u8; 8],
821}
822#[derive(Clone, Copy)]
823#[cfg_attr(feature = "debug-structs", derive(Debug))]
824#[repr(C)]
825pub struct PxSolverContactDesc {
826 pub invMassScales: PxConstraintInvMassScale,
827 pub desc: *mut PxSolverConstraintDesc,
828 pub body0: *const PxSolverBody,
829 pub body1: *const PxSolverBody,
830 pub data0: *const PxSolverBodyData,
831 pub data1: *const PxSolverBodyData,
832 pub bodyFrame0: PxTransform,
833 pub bodyFrame1: PxTransform,
834 pub bodyState0: BodyState,
835 pub bodyState1: BodyState,
836 pub shapeInteraction: *mut std::ffi::c_void,
837 pub contacts: *mut PxContactPoint,
838 pub numContacts: u32,
839 pub hasMaxImpulse: bool,
840 pub disableStrongFriction: bool,
841 pub hasForceThresholds: bool,
842 pub structgen_pad0: [u8; 1],
843 pub restDistance: f32,
844 pub maxCCDSeparation: f32,
845 pub frictionPtr: *mut u8,
846 pub frictionCount: u8,
847 pub structgen_pad1: [u8; 7],
848 pub contactForces: *mut f32,
849 pub startFrictionPatchIndex: u32,
850 pub numFrictionPatches: u32,
851 pub startContactPatchIndex: u32,
852 pub numContactPatches: u16,
853 pub axisConstraintCount: u16,
854 pub offsetSlop: f32,
855 pub structgen_pad2: [u8; 12],
856}
857#[derive(Clone, Copy)]
858#[cfg_attr(feature = "debug-structs", derive(Debug))]
859#[repr(C)]
860pub struct PxArticulationLimit {
861 pub low: f32,
862 pub high: f32,
863}
864#[derive(Clone, Copy)]
865#[cfg_attr(feature = "debug-structs", derive(Debug))]
866#[repr(C)]
867pub struct PxArticulationDrive {
868 pub stiffness: f32,
869 pub damping: f32,
870 pub maxForce: f32,
871 pub driveType: PxArticulationDriveType,
872}
873#[derive(Clone, Copy)]
874#[cfg_attr(feature = "debug-structs", derive(Debug))]
875#[repr(C)]
876pub struct PxTGSSolverBodyVel {
877 pub linearVelocity: PxVec3,
878 pub nbStaticInteractions: u16,
879 pub maxDynamicPartition: u16,
880 pub angularVelocity: PxVec3,
881 pub partitionMask: u32,
882 pub deltaAngDt: PxVec3,
883 pub maxAngVel: f32,
884 pub deltaLinDt: PxVec3,
885 pub lockFlags: u16,
886 pub isKinematic: bool,
887 pub pad: u8,
888}
889#[derive(Clone, Copy)]
890#[cfg_attr(feature = "debug-structs", derive(Debug))]
891#[repr(C)]
892pub struct PxTGSSolverBodyTxInertia {
893 pub deltaBody2World: PxTransform,
894 pub sqrtInvInertia: PxMat33,
895}
896#[derive(Clone, Copy)]
897#[cfg_attr(feature = "debug-structs", derive(Debug))]
898#[repr(C)]
899pub struct PxTGSSolverBodyData {
900 pub originalLinearVelocity: PxVec3,
901 pub maxContactImpulse: f32,
902 pub originalAngularVelocity: PxVec3,
903 pub penBiasClamp: f32,
904 pub invMass: f32,
905 pub nodeIndex: u32,
906 pub reportThreshold: f32,
907 pub pad: u32,
908}
909#[derive(Clone, Copy)]
910#[cfg_attr(feature = "debug-structs", derive(Debug))]
911#[repr(C)]
912pub struct PxTGSSolverConstraintPrepDescBase {
913 pub invMassScales: PxConstraintInvMassScale,
914 pub desc: *mut PxSolverConstraintDesc,
915 pub body0: *const PxTGSSolverBodyVel,
916 pub body1: *const PxTGSSolverBodyVel,
917 pub body0TxI: *const PxTGSSolverBodyTxInertia,
918 pub body1TxI: *const PxTGSSolverBodyTxInertia,
919 pub bodyData0: *const PxTGSSolverBodyData,
920 pub bodyData1: *const PxTGSSolverBodyData,
921 pub bodyFrame0: PxTransform,
922 pub bodyFrame1: PxTransform,
923 pub bodyState0: BodyState,
924 pub bodyState1: BodyState,
925 pub structgen_pad0: [u8; 8],
926}
927#[derive(Clone, Copy)]
928#[cfg_attr(feature = "debug-structs", derive(Debug))]
929#[repr(C)]
930pub struct PxTGSSolverConstraintPrepDesc {
931 pub invMassScales: PxConstraintInvMassScale,
932 pub desc: *mut PxSolverConstraintDesc,
933 pub body0: *const PxTGSSolverBodyVel,
934 pub body1: *const PxTGSSolverBodyVel,
935 pub body0TxI: *const PxTGSSolverBodyTxInertia,
936 pub body1TxI: *const PxTGSSolverBodyTxInertia,
937 pub bodyData0: *const PxTGSSolverBodyData,
938 pub bodyData1: *const PxTGSSolverBodyData,
939 pub bodyFrame0: PxTransform,
940 pub bodyFrame1: PxTransform,
941 pub bodyState0: BodyState,
942 pub bodyState1: BodyState,
943 pub rows: *mut Px1DConstraint,
944 pub numRows: u32,
945 pub linBreakForce: f32,
946 pub angBreakForce: f32,
947 pub minResponseThreshold: f32,
948 pub writeback: *mut std::ffi::c_void,
949 pub disablePreprocessing: bool,
950 pub improvedSlerp: bool,
951 pub driveLimitsAreForces: bool,
952 pub extendedLimits: bool,
953 pub disableConstraint: bool,
954 pub structgen_pad0: [u8; 3],
955 pub body0WorldOffset: PxVec3Padded,
956 pub cA2w: PxVec3Padded,
957 pub cB2w: PxVec3Padded,
958}
959#[derive(Clone, Copy)]
960#[cfg_attr(feature = "debug-structs", derive(Debug))]
961#[repr(C)]
962pub struct PxTGSSolverContactDesc {
963 pub invMassScales: PxConstraintInvMassScale,
964 pub desc: *mut PxSolverConstraintDesc,
965 pub body0: *const PxTGSSolverBodyVel,
966 pub body1: *const PxTGSSolverBodyVel,
967 pub body0TxI: *const PxTGSSolverBodyTxInertia,
968 pub body1TxI: *const PxTGSSolverBodyTxInertia,
969 pub bodyData0: *const PxTGSSolverBodyData,
970 pub bodyData1: *const PxTGSSolverBodyData,
971 pub bodyFrame0: PxTransform,
972 pub bodyFrame1: PxTransform,
973 pub bodyState0: BodyState,
974 pub bodyState1: BodyState,
975 pub shapeInteraction: *mut std::ffi::c_void,
976 pub contacts: *mut PxContactPoint,
977 pub numContacts: u32,
978 pub hasMaxImpulse: bool,
979 pub disableStrongFriction: bool,
980 pub hasForceThresholds: bool,
981 pub structgen_pad0: [u8; 1],
982 pub restDistance: f32,
983 pub maxCCDSeparation: f32,
984 pub frictionPtr: *mut u8,
985 pub frictionCount: u8,
986 pub structgen_pad1: [u8; 7],
987 pub contactForces: *mut f32,
988 pub startFrictionPatchIndex: u32,
989 pub numFrictionPatches: u32,
990 pub startContactPatchIndex: u32,
991 pub numContactPatches: u16,
992 pub axisConstraintCount: u16,
993 pub maxImpulse: f32,
994 pub torsionalPatchRadius: f32,
995 pub minTorsionalPatchRadius: f32,
996 pub offsetSlop: f32,
997}
998#[derive(Clone, Copy)]
999#[cfg_attr(feature = "debug-structs", derive(Debug))]
1000#[repr(C)]
1001pub struct PxArticulationTendonLimit {
1002 pub lowLimit: f32,
1003 pub highLimit: f32,
1004}
1005#[derive(Clone, Copy)]
1006#[cfg_attr(feature = "debug-structs", derive(Debug))]
1007#[repr(C)]
1008pub struct PxArticulationAttachment {
1009 pub structgen_pad0: [u8; 16],
1010 pub userData: *mut std::ffi::c_void,
1011}
1012#[derive(Clone, Copy)]
1013#[cfg_attr(feature = "debug-structs", derive(Debug))]
1014#[repr(C)]
1015pub struct PxArticulationTendonJoint {
1016 pub structgen_pad0: [u8; 16],
1017 pub userData: *mut std::ffi::c_void,
1018}
1019#[derive(Clone, Copy)]
1020#[cfg_attr(feature = "debug-structs", derive(Debug))]
1021#[repr(C)]
1022pub struct PxArticulationTendon {
1023 pub structgen_pad0: [u8; 16],
1024 pub userData: *mut std::ffi::c_void,
1025}
1026#[derive(Clone, Copy)]
1027#[cfg_attr(feature = "debug-structs", derive(Debug))]
1028#[repr(C)]
1029pub struct PxArticulationSpatialTendon {
1030 pub structgen_pad0: [u8; 16],
1031 pub userData: *mut std::ffi::c_void,
1032}
1033#[derive(Clone, Copy)]
1034#[cfg_attr(feature = "debug-structs", derive(Debug))]
1035#[repr(C)]
1036pub struct PxArticulationFixedTendon {
1037 pub structgen_pad0: [u8; 16],
1038 pub userData: *mut std::ffi::c_void,
1039}
1040#[derive(Clone, Copy)]
1041#[cfg_attr(feature = "debug-structs", derive(Debug))]
1042#[repr(C)]
1043pub struct PxSpatialForce {
1044 pub force: PxVec3,
1045 pub pad0: f32,
1046 pub torque: PxVec3,
1047 pub pad1: f32,
1048}
1049#[derive(Clone, Copy)]
1050#[cfg_attr(feature = "debug-structs", derive(Debug))]
1051#[repr(C)]
1052pub struct PxSpatialVelocity {
1053 pub linear: PxVec3,
1054 pub pad0: f32,
1055 pub angular: PxVec3,
1056 pub pad1: f32,
1057}
1058#[derive(Clone, Copy)]
1059#[cfg_attr(feature = "debug-structs", derive(Debug))]
1060#[repr(C)]
1061pub struct PxArticulationRootLinkData {
1062 pub transform: PxTransform,
1063 pub worldLinVel: PxVec3,
1064 pub worldAngVel: PxVec3,
1065 pub worldLinAccel: PxVec3,
1066 pub worldAngAccel: PxVec3,
1067}
1068#[derive(Clone, Copy)]
1069#[cfg_attr(feature = "debug-structs", derive(Debug))]
1070#[repr(C)]
1071pub struct PxArticulationCache {
1072 pub externalForces: *mut PxSpatialForce,
1073 pub denseJacobian: *mut f32,
1074 pub massMatrix: *mut f32,
1075 pub jointVelocity: *mut f32,
1076 pub jointAcceleration: *mut f32,
1077 pub jointPosition: *mut f32,
1078 pub jointForce: *mut f32,
1079 pub jointSolverForces: *mut f32,
1080 pub linkVelocity: *mut PxSpatialVelocity,
1081 pub linkAcceleration: *mut PxSpatialVelocity,
1082 pub rootLinkData: *mut PxArticulationRootLinkData,
1083 pub sensorForces: *mut PxSpatialForce,
1084 pub coefficientMatrix: *mut f32,
1085 pub lambda: *mut f32,
1086 pub scratchMemory: *mut std::ffi::c_void,
1087 pub scratchAllocator: *mut std::ffi::c_void,
1088 pub version: u32,
1089 pub structgen_pad0: [u8; 4],
1090}
1091#[derive(Clone, Copy)]
1092#[cfg_attr(feature = "debug-structs", derive(Debug))]
1093#[repr(C)]
1094pub struct PxArticulationSensor {
1095 pub structgen_pad0: [u8; 16],
1096 pub userData: *mut std::ffi::c_void,
1097}
1098#[derive(Clone, Copy)]
1099#[cfg_attr(feature = "debug-structs", derive(Debug))]
1100#[repr(C)]
1101pub struct PxArticulationReducedCoordinate {
1102 pub structgen_pad0: [u8; 16],
1103 pub userData: *mut std::ffi::c_void,
1104}
1105#[derive(Clone, Copy)]
1106#[cfg_attr(feature = "debug-structs", derive(Debug))]
1107#[repr(C)]
1108pub struct PxArticulationJointReducedCoordinate {
1109 pub structgen_pad0: [u8; 16],
1110 pub userData: *mut std::ffi::c_void,
1111}
1112#[derive(Clone, Copy)]
1113#[cfg_attr(feature = "debug-structs", derive(Debug))]
1114#[repr(C)]
1115pub struct PxShape {
1116 pub structgen_pad0: [u8; 16],
1117 pub userData: *mut std::ffi::c_void,
1118}
1119#[derive(Clone, Copy)]
1120#[cfg_attr(feature = "debug-structs", derive(Debug))]
1121#[repr(C)]
1122pub struct PxRigidActor {
1123 pub structgen_pad0: [u8; 16],
1124 pub userData: *mut std::ffi::c_void,
1125}
1126#[derive(Clone, Copy)]
1127#[cfg_attr(feature = "debug-structs", derive(Debug))]
1128#[repr(C)]
1129pub struct PxNodeIndex {
1130 pub structgen_pad0: [u8; 8],
1131}
1132#[derive(Clone, Copy)]
1133#[cfg_attr(feature = "debug-structs", derive(Debug))]
1134#[repr(C)]
1135pub struct PxRigidBody {
1136 pub structgen_pad0: [u8; 16],
1137 pub userData: *mut std::ffi::c_void,
1138}
1139#[derive(Clone, Copy)]
1140#[cfg_attr(feature = "debug-structs", derive(Debug))]
1141#[repr(C)]
1142pub struct PxArticulationLink {
1143 pub structgen_pad0: [u8; 16],
1144 pub userData: *mut std::ffi::c_void,
1145}
1146#[derive(Clone, Copy)]
1147#[cfg_attr(feature = "debug-structs", derive(Debug))]
1148#[repr(C)]
1149pub struct PxConeLimitedConstraint {
1150 pub mAxis: PxVec3,
1151 pub mAngle: f32,
1152 pub mLowLimit: f32,
1153 pub mHighLimit: f32,
1154}
1155#[derive(Clone, Copy)]
1156#[cfg_attr(feature = "debug-structs", derive(Debug))]
1157#[repr(C)]
1158pub struct PxConeLimitParams {
1159 pub lowHighLimits: PxVec4,
1160 pub axisAngle: PxVec4,
1161}
1162#[derive(Clone, Copy)]
1163#[cfg_attr(feature = "debug-structs", derive(Debug))]
1164#[repr(C)]
1165pub struct PxConstraintShaderTable {
1166 pub solverPrep: *mut std::ffi::c_void,
1167 pub structgen_pad0: [u8; 8],
1168 pub visualize: *mut std::ffi::c_void,
1169 pub flag: PxConstraintFlag,
1170 pub structgen_pad1: [u8; 4],
1171}
1172#[derive(Clone, Copy)]
1173#[cfg_attr(feature = "debug-structs", derive(Debug))]
1174#[repr(C)]
1175pub struct PxConstraint {
1176 pub structgen_pad0: [u8; 16],
1177 pub userData: *mut std::ffi::c_void,
1178}
1179#[derive(Clone, Copy)]
1180#[cfg_attr(feature = "debug-structs", derive(Debug))]
1181#[repr(C)]
1182pub struct PxMassModificationProps {
1183 pub mInvMassScale0: f32,
1184 pub mInvInertiaScale0: f32,
1185 pub mInvMassScale1: f32,
1186 pub mInvInertiaScale1: f32,
1187}
1188#[derive(Clone, Copy)]
1189#[cfg_attr(feature = "debug-structs", derive(Debug))]
1190#[repr(C)]
1191pub struct PxContactPatch {
1192 pub mMassModification: PxMassModificationProps,
1193 pub normal: PxVec3,
1194 pub restitution: f32,
1195 pub dynamicFriction: f32,
1196 pub staticFriction: f32,
1197 pub damping: f32,
1198 pub startContactIndex: u16,
1199 pub nbContacts: u8,
1200 pub materialFlags: u8,
1201 pub internalFlags: u16,
1202 pub materialIndex0: u16,
1203 pub materialIndex1: u16,
1204 pub pad: [u16; 5],
1205}
1206#[derive(Clone, Copy)]
1207#[cfg_attr(feature = "debug-structs", derive(Debug))]
1208#[repr(C)]
1209pub struct PxContact {
1210 pub contact: PxVec3,
1211 pub separation: f32,
1212}
1213#[derive(Clone, Copy)]
1214#[cfg_attr(feature = "debug-structs", derive(Debug))]
1215#[repr(C)]
1216pub struct PxExtendedContact {
1217 pub contact: PxVec3,
1218 pub separation: f32,
1219 pub targetVelocity: PxVec3,
1220 pub maxImpulse: f32,
1221}
1222#[derive(Clone, Copy)]
1223#[cfg_attr(feature = "debug-structs", derive(Debug))]
1224#[repr(C)]
1225pub struct PxModifiableContact {
1226 pub contact: PxVec3,
1227 pub separation: f32,
1228 pub targetVelocity: PxVec3,
1229 pub maxImpulse: f32,
1230 pub normal: PxVec3,
1231 pub restitution: f32,
1232 pub materialFlags: u32,
1233 pub materialIndex0: u16,
1234 pub materialIndex1: u16,
1235 pub staticFriction: f32,
1236 pub dynamicFriction: f32,
1237}
1238#[derive(Clone, Copy)]
1239#[cfg_attr(feature = "debug-structs", derive(Debug))]
1240#[repr(C)]
1241pub struct PxContactStreamIterator {
1242 pub zero: PxVec3,
1243 pub structgen_pad0: [u8; 4],
1244 pub patch: *const PxContactPatch,
1245 pub contact: *const PxContact,
1246 pub faceIndice: *const u32,
1247 pub totalPatches: u32,
1248 pub totalContacts: u32,
1249 pub nextContactIndex: u32,
1250 pub nextPatchIndex: u32,
1251 pub contactPatchHeaderSize: u32,
1252 pub contactPointSize: u32,
1253 pub mStreamFormat: StreamFormat,
1254 pub forceNoResponse: u32,
1255 pub pointStepped: bool,
1256 pub structgen_pad1: [u8; 3],
1257 pub hasFaceIndices: u32,
1258}
1259#[derive(Clone, Copy)]
1260#[cfg_attr(feature = "debug-structs", derive(Debug))]
1261#[repr(C)]
1262pub struct PxGpuContactPair {
1263 pub contactPatches: *mut u8,
1264 pub contactPoints: *mut u8,
1265 pub contactForces: *mut f32,
1266 pub transformCacheRef0: u32,
1267 pub transformCacheRef1: u32,
1268 pub nodeIndex0: PxNodeIndex,
1269 pub nodeIndex1: PxNodeIndex,
1270 pub actor0: *mut PxActor,
1271 pub actor1: *mut PxActor,
1272 pub nbContacts: u16,
1273 pub nbPatches: u16,
1274 pub structgen_pad0: [u8; 4],
1275}
1276#[derive(Clone, Copy)]
1277#[cfg_attr(feature = "debug-structs", derive(Debug))]
1278#[repr(C)]
1279pub struct PxContactSet {
1280 pub structgen_pad0: [u8; 16],
1281}
1282#[derive(Clone, Copy)]
1283#[cfg_attr(feature = "debug-structs", derive(Debug))]
1284#[repr(C)]
1285pub struct PxContactModifyPair {
1286 pub actor: [*const PxRigidActor; 2],
1287 pub shape: [*const PxShape; 2],
1288 pub transform: [PxTransform; 2],
1289 pub contacts: PxContactSet,
1290}
1291#[derive(Clone, Copy)]
1292#[cfg_attr(feature = "debug-structs", derive(Debug))]
1293#[repr(C)]
1294pub struct PxBaseMaterial {
1295 pub structgen_pad0: [u8; 16],
1296 pub userData: *mut std::ffi::c_void,
1297}
1298#[derive(Clone, Copy)]
1299#[cfg_attr(feature = "debug-structs", derive(Debug))]
1300#[repr(C)]
1301pub struct PxFEMMaterial {
1302 pub structgen_pad0: [u8; 16],
1303 pub userData: *mut std::ffi::c_void,
1304}
1305#[derive(Clone, Copy)]
1306#[cfg_attr(feature = "debug-structs", derive(Debug))]
1307#[repr(C)]
1308pub struct PxFilterData {
1309 pub word0: u32,
1310 pub word1: u32,
1311 pub word2: u32,
1312 pub word3: u32,
1313}
1314#[derive(Clone, Copy)]
1315#[cfg_attr(feature = "debug-structs", derive(Debug))]
1316#[repr(C)]
1317pub struct PxParticleRigidFilterPair {
1318 pub mID0: u64,
1319 pub mID1: u64,
1320}
1321#[derive(Clone, Copy)]
1322#[cfg_attr(feature = "debug-structs", derive(Debug))]
1323#[repr(C)]
1324pub struct PxMaterial {
1325 pub structgen_pad0: [u8; 16],
1326 pub userData: *mut std::ffi::c_void,
1327}
1328#[derive(Clone, Copy)]
1329#[cfg_attr(feature = "debug-structs", derive(Debug))]
1330#[repr(C)]
1331pub struct PxGpuParticleBufferIndexPair {
1332 pub systemIndex: u32,
1333 pub bufferIndex: u32,
1334}
1335#[derive(Clone, Copy)]
1336#[cfg_attr(feature = "debug-structs", derive(Debug))]
1337#[repr(C)]
1338pub struct PxParticleVolume {
1339 pub bound: PxBounds3,
1340 pub particleIndicesOffset: u32,
1341 pub numParticles: u32,
1342}
1343#[derive(Clone, Copy)]
1344#[cfg_attr(feature = "debug-structs", derive(Debug))]
1345#[repr(C)]
1346pub struct PxDiffuseParticleParams {
1347 pub threshold: f32,
1348 pub lifetime: f32,
1349 pub airDrag: f32,
1350 pub bubbleDrag: f32,
1351 pub buoyancy: f32,
1352 pub kineticEnergyWeight: f32,
1353 pub pressureWeight: f32,
1354 pub divergenceWeight: f32,
1355 pub collisionDecay: f32,
1356 pub useAccurateVelocity: bool,
1357 pub structgen_pad0: [u8; 3],
1358}
1359#[derive(Clone, Copy)]
1360#[cfg_attr(feature = "debug-structs", derive(Debug))]
1361#[repr(C)]
1362pub struct PxParticleSpring {
1363 pub ind0: u32,
1364 pub ind1: u32,
1365 pub length: f32,
1366 pub stiffness: f32,
1367 pub damping: f32,
1368 pub pad: f32,
1369}
1370#[derive(Clone, Copy)]
1371#[cfg_attr(feature = "debug-structs", derive(Debug))]
1372#[repr(C)]
1373pub struct PxParticleMaterial {
1374 pub structgen_pad0: [u8; 16],
1375 pub userData: *mut std::ffi::c_void,
1376}
1377#[derive(Clone, Copy)]
1378#[cfg_attr(feature = "debug-structs", derive(Debug))]
1379#[repr(C)]
1380pub struct PxActorShape {
1381 pub actor: *mut PxRigidActor,
1382 pub shape: *mut PxShape,
1383}
1384#[derive(Clone, Copy)]
1385#[cfg_attr(feature = "debug-structs", derive(Debug))]
1386#[repr(C)]
1387pub struct PxRaycastHit {
1388 pub faceIndex: u32,
1389 pub flags: PxHitFlags,
1390 pub structgen_pad0: [u8; 2],
1391 pub position: PxVec3,
1392 pub normal: PxVec3,
1393 pub distance: f32,
1394 pub u: f32,
1395 pub v: f32,
1396 pub structgen_pad1: [u8; 4],
1397 pub actor: *mut PxRigidActor,
1398 pub shape: *mut PxShape,
1399}
1400#[derive(Clone, Copy)]
1401#[cfg_attr(feature = "debug-structs", derive(Debug))]
1402#[repr(C)]
1403pub struct PxOverlapHit {
1404 pub faceIndex: u32,
1405 pub structgen_pad0: [u8; 4],
1406 pub actor: *mut PxRigidActor,
1407 pub shape: *mut PxShape,
1408}
1409#[derive(Clone, Copy)]
1410#[cfg_attr(feature = "debug-structs", derive(Debug))]
1411#[repr(C)]
1412pub struct PxSweepHit {
1413 pub faceIndex: u32,
1414 pub flags: PxHitFlags,
1415 pub structgen_pad0: [u8; 2],
1416 pub position: PxVec3,
1417 pub normal: PxVec3,
1418 pub distance: f32,
1419 pub structgen_pad1: [u8; 4],
1420 pub actor: *mut PxRigidActor,
1421 pub shape: *mut PxShape,
1422}
1423#[derive(Clone, Copy)]
1424#[cfg_attr(feature = "debug-structs", derive(Debug))]
1425#[repr(C)]
1426pub struct PxRaycastCallback {
1427 pub structgen_pad0: [u8; 8],
1428 pub block: PxRaycastHit,
1429 pub hasBlock: bool,
1430 pub structgen_pad1: [u8; 7],
1431 pub touches: *mut PxRaycastHit,
1432 pub maxNbTouches: u32,
1433 pub nbTouches: u32,
1434}
1435#[derive(Clone, Copy)]
1436#[cfg_attr(feature = "debug-structs", derive(Debug))]
1437#[repr(C)]
1438pub struct PxOverlapCallback {
1439 pub structgen_pad0: [u8; 8],
1440 pub block: PxOverlapHit,
1441 pub hasBlock: bool,
1442 pub structgen_pad1: [u8; 7],
1443 pub touches: *mut PxOverlapHit,
1444 pub maxNbTouches: u32,
1445 pub nbTouches: u32,
1446}
1447#[derive(Clone, Copy)]
1448#[cfg_attr(feature = "debug-structs", derive(Debug))]
1449#[repr(C)]
1450pub struct PxSweepCallback {
1451 pub structgen_pad0: [u8; 8],
1452 pub block: PxSweepHit,
1453 pub hasBlock: bool,
1454 pub structgen_pad1: [u8; 7],
1455 pub touches: *mut PxSweepHit,
1456 pub maxNbTouches: u32,
1457 pub nbTouches: u32,
1458}
1459#[derive(Clone, Copy)]
1460#[cfg_attr(feature = "debug-structs", derive(Debug))]
1461#[repr(C)]
1462pub struct PxRaycastBuffer {
1463 pub structgen_pad0: [u8; 8],
1464 pub block: PxRaycastHit,
1465 pub hasBlock: bool,
1466 pub structgen_pad1: [u8; 7],
1467 pub touches: *mut PxRaycastHit,
1468 pub maxNbTouches: u32,
1469 pub nbTouches: u32,
1470}
1471#[derive(Clone, Copy)]
1472#[cfg_attr(feature = "debug-structs", derive(Debug))]
1473#[repr(C)]
1474pub struct PxOverlapBuffer {
1475 pub structgen_pad0: [u8; 8],
1476 pub block: PxOverlapHit,
1477 pub hasBlock: bool,
1478 pub structgen_pad1: [u8; 7],
1479 pub touches: *mut PxOverlapHit,
1480 pub maxNbTouches: u32,
1481 pub nbTouches: u32,
1482}
1483#[derive(Clone, Copy)]
1484#[cfg_attr(feature = "debug-structs", derive(Debug))]
1485#[repr(C)]
1486pub struct PxSweepBuffer {
1487 pub structgen_pad0: [u8; 8],
1488 pub block: PxSweepHit,
1489 pub hasBlock: bool,
1490 pub structgen_pad1: [u8; 7],
1491 pub touches: *mut PxSweepHit,
1492 pub maxNbTouches: u32,
1493 pub nbTouches: u32,
1494}
1495#[derive(Clone, Copy)]
1496#[cfg_attr(feature = "debug-structs", derive(Debug))]
1497#[repr(C)]
1498pub struct PxQueryCache {
1499 pub shape: *mut PxShape,
1500 pub actor: *mut PxRigidActor,
1501 pub faceIndex: u32,
1502 pub structgen_pad0: [u8; 4],
1503}
1504#[derive(Clone, Copy)]
1505#[cfg_attr(feature = "debug-structs", derive(Debug))]
1506#[repr(C)]
1507pub struct PxQueryFilterData {
1508 pub data: PxFilterData,
1509 pub flags: PxQueryFlags,
1510 pub structgen_pad0: [u8; 2],
1511}
1512#[derive(Clone, Copy)]
1513#[cfg_attr(feature = "debug-structs", derive(Debug))]
1514#[repr(C)]
1515pub struct PxRigidDynamic {
1516 pub structgen_pad0: [u8; 16],
1517 pub userData: *mut std::ffi::c_void,
1518}
1519#[derive(Clone, Copy)]
1520#[cfg_attr(feature = "debug-structs", derive(Debug))]
1521#[repr(C)]
1522pub struct PxRigidStatic {
1523 pub structgen_pad0: [u8; 16],
1524 pub userData: *mut std::ffi::c_void,
1525}
1526#[derive(Clone, Copy)]
1527#[cfg_attr(feature = "debug-structs", derive(Debug))]
1528#[repr(C)]
1529pub struct PxSceneQueryDesc {
1530 pub staticStructure: PxPruningStructureType,
1531 pub dynamicStructure: PxPruningStructureType,
1532 pub dynamicTreeRebuildRateHint: u32,
1533 pub dynamicTreeSecondaryPruner: PxDynamicTreeSecondaryPruner,
1534 pub staticBVHBuildStrategy: PxBVHBuildStrategy,
1535 pub dynamicBVHBuildStrategy: PxBVHBuildStrategy,
1536 pub staticNbObjectsPerNode: u32,
1537 pub dynamicNbObjectsPerNode: u32,
1538 pub sceneQueryUpdateMode: PxSceneQueryUpdateMode,
1539}
1540#[derive(Clone, Copy)]
1541#[cfg_attr(feature = "debug-structs", derive(Debug))]
1542#[repr(C)]
1543pub struct PxBroadPhaseRegion {
1544 pub mBounds: PxBounds3,
1545 pub mUserData: *mut std::ffi::c_void,
1546}
1547#[derive(Clone, Copy)]
1548#[cfg_attr(feature = "debug-structs", derive(Debug))]
1549#[repr(C)]
1550pub struct PxBroadPhaseRegionInfo {
1551 pub mRegion: PxBroadPhaseRegion,
1552 pub mNbStaticObjects: u32,
1553 pub mNbDynamicObjects: u32,
1554 pub mActive: bool,
1555 pub mOverlap: bool,
1556 pub structgen_pad0: [u8; 6],
1557}
1558#[derive(Clone, Copy)]
1559#[cfg_attr(feature = "debug-structs", derive(Debug))]
1560#[repr(C)]
1561pub struct PxBroadPhaseCaps {
1562 pub mMaxNbRegions: u32,
1563}
1564#[derive(Clone, Copy)]
1565#[cfg_attr(feature = "debug-structs", derive(Debug))]
1566#[repr(C)]
1567pub struct PxBroadPhaseDesc {
1568 pub mType: PxBroadPhaseType,
1569 pub structgen_pad0: [u8; 4],
1570 pub mContextID: u64,
1571 pub structgen_pad1: [u8; 8],
1572 pub mFoundLostPairsCapacity: u32,
1573 pub mDiscardStaticVsKinematic: bool,
1574 pub mDiscardKinematicVsKinematic: bool,
1575 pub structgen_pad2: [u8; 2],
1576}
1577#[derive(Clone, Copy)]
1578#[cfg_attr(feature = "debug-structs", derive(Debug))]
1579#[repr(C)]
1580pub struct PxBroadPhaseUpdateData {
1581 pub mCreated: *const u32,
1582 pub mNbCreated: u32,
1583 pub structgen_pad0: [u8; 4],
1584 pub mUpdated: *const u32,
1585 pub mNbUpdated: u32,
1586 pub structgen_pad1: [u8; 4],
1587 pub mRemoved: *const u32,
1588 pub mNbRemoved: u32,
1589 pub structgen_pad2: [u8; 4],
1590 pub mBounds: *const PxBounds3,
1591 pub mGroups: *const u32,
1592 pub mDistances: *const f32,
1593 pub mCapacity: u32,
1594 pub structgen_pad3: [u8; 4],
1595}
1596#[derive(Clone, Copy)]
1597#[cfg_attr(feature = "debug-structs", derive(Debug))]
1598#[repr(C)]
1599pub struct PxBroadPhasePair {
1600 pub mID0: u32,
1601 pub mID1: u32,
1602}
1603#[derive(Clone, Copy)]
1604#[cfg_attr(feature = "debug-structs", derive(Debug))]
1605#[repr(C)]
1606pub struct PxBroadPhaseResults {
1607 pub mNbCreatedPairs: u32,
1608 pub structgen_pad0: [u8; 4],
1609 pub mCreatedPairs: *const PxBroadPhasePair,
1610 pub mNbDeletedPairs: u32,
1611 pub structgen_pad1: [u8; 4],
1612 pub mDeletedPairs: *const PxBroadPhasePair,
1613}
1614#[derive(Clone, Copy)]
1615#[cfg_attr(feature = "debug-structs", derive(Debug))]
1616#[repr(C)]
1617pub struct PxSceneLimits {
1618 pub maxNbActors: u32,
1619 pub maxNbBodies: u32,
1620 pub maxNbStaticShapes: u32,
1621 pub maxNbDynamicShapes: u32,
1622 pub maxNbAggregates: u32,
1623 pub maxNbConstraints: u32,
1624 pub maxNbRegions: u32,
1625 pub maxNbBroadPhaseOverlaps: u32,
1626}
1627#[derive(Clone, Copy)]
1628#[cfg_attr(feature = "debug-structs", derive(Debug))]
1629#[repr(C)]
1630pub struct PxgDynamicsMemoryConfig {
1631 pub tempBufferCapacity: u32,
1632 pub maxRigidContactCount: u32,
1633 pub maxRigidPatchCount: u32,
1634 pub heapCapacity: u32,
1635 pub foundLostPairsCapacity: u32,
1636 pub foundLostAggregatePairsCapacity: u32,
1637 pub totalAggregatePairsCapacity: u32,
1638 pub maxSoftBodyContacts: u32,
1639 pub maxFemClothContacts: u32,
1640 pub maxParticleContacts: u32,
1641 pub collisionStackSize: u32,
1642 pub maxHairContacts: u32,
1643}
1644#[derive(Clone, Copy)]
1645#[cfg_attr(feature = "debug-structs", derive(Debug))]
1646#[repr(C)]
1647pub struct PxSceneDesc {
1648 pub staticStructure: PxPruningStructureType,
1649 pub dynamicStructure: PxPruningStructureType,
1650 pub dynamicTreeRebuildRateHint: u32,
1651 pub dynamicTreeSecondaryPruner: PxDynamicTreeSecondaryPruner,
1652 pub staticBVHBuildStrategy: PxBVHBuildStrategy,
1653 pub dynamicBVHBuildStrategy: PxBVHBuildStrategy,
1654 pub staticNbObjectsPerNode: u32,
1655 pub dynamicNbObjectsPerNode: u32,
1656 pub sceneQueryUpdateMode: PxSceneQueryUpdateMode,
1657 pub gravity: PxVec3,
1658 pub simulationEventCallback: *mut PxSimulationEventCallback,
1659 pub contactModifyCallback: *mut PxContactModifyCallback,
1660 pub ccdContactModifyCallback: *mut PxCCDContactModifyCallback,
1661 pub filterShaderData: *const std::ffi::c_void,
1662 pub filterShaderDataSize: u32,
1663 pub structgen_pad0: [u8; 4],
1664 pub filterShader: *mut std::ffi::c_void,
1665 pub filterCallback: *mut PxSimulationFilterCallback,
1666 pub kineKineFilteringMode: PxPairFilteringMode,
1667 pub staticKineFilteringMode: PxPairFilteringMode,
1668 pub broadPhaseType: PxBroadPhaseType,
1669 pub structgen_pad1: [u8; 4],
1670 pub broadPhaseCallback: *mut PxBroadPhaseCallback,
1671 pub limits: PxSceneLimits,
1672 pub frictionType: PxFrictionType,
1673 pub solverType: PxSolverType,
1674 pub bounceThresholdVelocity: f32,
1675 pub frictionOffsetThreshold: f32,
1676 pub frictionCorrelationDistance: f32,
1677 pub flags: PxSceneFlags,
1678 pub cpuDispatcher: *mut PxCpuDispatcher,
1679 pub structgen_pad2: [u8; 8],
1680 pub userData: *mut std::ffi::c_void,
1681 pub solverBatchSize: u32,
1682 pub solverArticulationBatchSize: u32,
1683 pub nbContactDataBlocks: u32,
1684 pub maxNbContactDataBlocks: u32,
1685 pub maxBiasCoefficient: f32,
1686 pub contactReportStreamBufferSize: u32,
1687 pub ccdMaxPasses: u32,
1688 pub ccdThreshold: f32,
1689 pub ccdMaxSeparation: f32,
1690 pub wakeCounterResetValue: f32,
1691 pub sanityBounds: PxBounds3,
1692 pub gpuDynamicsConfig: PxgDynamicsMemoryConfig,
1693 pub gpuMaxNumPartitions: u32,
1694 pub gpuMaxNumStaticPartitions: u32,
1695 pub gpuComputeVersion: u32,
1696 pub contactPairSlabSize: u32,
1697 pub sceneQuerySystem: *mut PxSceneQuerySystem,
1698 pub structgen_pad3: [u8; 8],
1699}
1700#[derive(Clone, Copy)]
1701#[cfg_attr(feature = "debug-structs", derive(Debug))]
1702#[repr(C)]
1703pub struct PxSimulationStatistics {
1704 pub nbActiveConstraints: u32,
1705 pub nbActiveDynamicBodies: u32,
1706 pub nbActiveKinematicBodies: u32,
1707 pub nbStaticBodies: u32,
1708 pub nbDynamicBodies: u32,
1709 pub nbKinematicBodies: u32,
1710 pub nbShapes: [u32; 11],
1711 pub nbAggregates: u32,
1712 pub nbArticulations: u32,
1713 pub nbAxisSolverConstraints: u32,
1714 pub compressedContactSize: u32,
1715 pub requiredContactConstraintMemory: u32,
1716 pub peakConstraintMemory: u32,
1717 pub nbDiscreteContactPairsTotal: u32,
1718 pub nbDiscreteContactPairsWithCacheHits: u32,
1719 pub nbDiscreteContactPairsWithContacts: u32,
1720 pub nbNewPairs: u32,
1721 pub nbLostPairs: u32,
1722 pub nbNewTouches: u32,
1723 pub nbLostTouches: u32,
1724 pub nbPartitions: u32,
1725 pub structgen_pad0: [u8; 4],
1726 pub gpuMemParticles: u64,
1727 pub gpuMemSoftBodies: u64,
1728 pub gpuMemFEMCloths: u64,
1729 pub gpuMemHairSystems: u64,
1730 pub gpuMemHeap: u64,
1731 pub gpuMemHeapBroadPhase: u64,
1732 pub gpuMemHeapNarrowPhase: u64,
1733 pub gpuMemHeapSolver: u64,
1734 pub gpuMemHeapArticulation: u64,
1735 pub gpuMemHeapSimulation: u64,
1736 pub gpuMemHeapSimulationArticulation: u64,
1737 pub gpuMemHeapSimulationParticles: u64,
1738 pub gpuMemHeapSimulationSoftBody: u64,
1739 pub gpuMemHeapSimulationFEMCloth: u64,
1740 pub gpuMemHeapSimulationHairSystem: u64,
1741 pub gpuMemHeapParticles: u64,
1742 pub gpuMemHeapSoftBodies: u64,
1743 pub gpuMemHeapFEMCloths: u64,
1744 pub gpuMemHeapHairSystems: u64,
1745 pub gpuMemHeapOther: u64,
1746 pub nbBroadPhaseAdds: u32,
1747 pub nbBroadPhaseRemoves: u32,
1748 pub nbDiscreteContactPairs: [[u32; 11]; 11],
1749 pub nbCCDPairs: [[u32; 11]; 11],
1750 pub nbModifiedContactPairs: [[u32; 11]; 11],
1751 pub nbTriggerPairs: [[u32; 11]; 11],
1752}
1753#[derive(Clone, Copy)]
1754#[cfg_attr(feature = "debug-structs", derive(Debug))]
1755#[repr(C)]
1756pub struct PxGpuBodyData {
1757 pub quat: PxQuat,
1758 pub pos: PxVec4,
1759 pub linVel: PxVec4,
1760 pub angVel: PxVec4,
1761}
1762#[derive(Clone, Copy)]
1763#[cfg_attr(feature = "debug-structs", derive(Debug))]
1764#[repr(C)]
1765pub struct PxGpuActorPair {
1766 pub srcIndex: u32,
1767 pub structgen_pad0: [u8; 4],
1768 pub nodeIndex: PxNodeIndex,
1769}
1770#[derive(Clone, Copy)]
1771#[cfg_attr(feature = "debug-structs", derive(Debug))]
1772#[repr(C)]
1773pub struct PxIndexDataPair {
1774 pub index: u32,
1775 pub structgen_pad0: [u8; 4],
1776 pub data: *mut std::ffi::c_void,
1777}
1778#[derive(Clone, Copy)]
1779#[cfg_attr(feature = "debug-structs", derive(Debug))]
1780#[repr(C)]
1781pub struct PxDominanceGroupPair {
1782 pub dominance0: u8,
1783 pub dominance1: u8,
1784}
1785#[derive(Clone, Copy)]
1786#[cfg_attr(feature = "debug-structs", derive(Debug))]
1787#[repr(C)]
1788pub struct PxScene {
1789 pub structgen_pad0: [u8; 8],
1790 pub userData: *mut std::ffi::c_void,
1791}
1792#[derive(Clone, Copy)]
1793#[cfg_attr(feature = "debug-structs", derive(Debug))]
1794#[repr(C)]
1795pub struct PxSceneReadLock {
1796 pub structgen_pad0: [u8; 8],
1797}
1798#[derive(Clone, Copy)]
1799#[cfg_attr(feature = "debug-structs", derive(Debug))]
1800#[repr(C)]
1801pub struct PxSceneWriteLock {
1802 pub structgen_pad0: [u8; 8],
1803}
1804#[derive(Clone, Copy)]
1805#[cfg_attr(feature = "debug-structs", derive(Debug))]
1806#[repr(C)]
1807pub struct PxContactPairExtraDataItem {
1808 pub type_: u8,
1809}
1810#[derive(Clone, Copy)]
1811#[cfg_attr(feature = "debug-structs", derive(Debug))]
1812#[repr(C)]
1813pub struct PxContactPairVelocity {
1814 pub type_: u8,
1815 pub structgen_pad0: [u8; 3],
1816 pub linearVelocity: [PxVec3; 2],
1817 pub angularVelocity: [PxVec3; 2],
1818}
1819#[derive(Clone, Copy)]
1820#[cfg_attr(feature = "debug-structs", derive(Debug))]
1821#[repr(C)]
1822pub struct PxContactPairPose {
1823 pub type_: u8,
1824 pub structgen_pad0: [u8; 3],
1825 pub globalPose: [PxTransform; 2],
1826}
1827#[derive(Clone, Copy)]
1828#[cfg_attr(feature = "debug-structs", derive(Debug))]
1829#[repr(C)]
1830pub struct PxContactPairIndex {
1831 pub type_: u8,
1832 pub structgen_pad0: [u8; 1],
1833 pub index: u16,
1834}
1835#[derive(Clone, Copy)]
1836#[cfg_attr(feature = "debug-structs", derive(Debug))]
1837#[repr(C)]
1838pub struct PxContactPairExtraDataIterator {
1839 pub currPtr: *const u8,
1840 pub endPtr: *const u8,
1841 pub preSolverVelocity: *const PxContactPairVelocity,
1842 pub postSolverVelocity: *const PxContactPairVelocity,
1843 pub eventPose: *const PxContactPairPose,
1844 pub contactPairIndex: u32,
1845 pub structgen_pad0: [u8; 4],
1846}
1847#[derive(Clone, Copy)]
1848#[cfg_attr(feature = "debug-structs", derive(Debug))]
1849#[repr(C)]
1850pub struct PxContactPairHeader {
1851 pub actors: [*mut PxActor; 2],
1852 pub extraDataStream: *const u8,
1853 pub extraDataStreamSize: u16,
1854 pub flags: PxContactPairHeaderFlags,
1855 pub structgen_pad0: [u8; 4],
1856 pub pairs: *const PxContactPair,
1857 pub nbPairs: u32,
1858 pub structgen_pad1: [u8; 4],
1859}
1860#[derive(Clone, Copy)]
1861#[cfg_attr(feature = "debug-structs", derive(Debug))]
1862#[repr(C)]
1863pub struct PxContactPairPoint {
1864 pub position: PxVec3,
1865 pub separation: f32,
1866 pub normal: PxVec3,
1867 pub internalFaceIndex0: u32,
1868 pub impulse: PxVec3,
1869 pub internalFaceIndex1: u32,
1870}
1871#[derive(Clone, Copy)]
1872#[cfg_attr(feature = "debug-structs", derive(Debug))]
1873#[repr(C)]
1874pub struct PxContactPair {
1875 pub shapes: [*mut PxShape; 2],
1876 pub contactPatches: *const u8,
1877 pub contactPoints: *const u8,
1878 pub contactImpulses: *const f32,
1879 pub requiredBufferSize: u32,
1880 pub contactCount: u8,
1881 pub patchCount: u8,
1882 pub contactStreamSize: u16,
1883 pub flags: PxContactPairFlags,
1884 pub events: PxPairFlags,
1885 pub internalData: [u32; 2],
1886 pub structgen_pad0: [u8; 4],
1887}
1888#[derive(Clone, Copy)]
1889#[cfg_attr(feature = "debug-structs", derive(Debug))]
1890#[repr(C)]
1891pub struct PxTriggerPair {
1892 pub triggerShape: *mut PxShape,
1893 pub triggerActor: *mut PxActor,
1894 pub otherShape: *mut PxShape,
1895 pub otherActor: *mut PxActor,
1896 pub status: PxPairFlag,
1897 pub flags: PxTriggerPairFlags,
1898 pub structgen_pad0: [u8; 3],
1899}
1900#[derive(Clone, Copy)]
1901#[cfg_attr(feature = "debug-structs", derive(Debug))]
1902#[repr(C)]
1903pub struct PxConstraintInfo {
1904 pub constraint: *mut PxConstraint,
1905 pub externalReference: *mut std::ffi::c_void,
1906 pub type_: u32,
1907 pub structgen_pad0: [u8; 4],
1908}
1909#[derive(Clone, Copy)]
1910#[cfg_attr(feature = "debug-structs", derive(Debug))]
1911#[repr(C)]
1912pub struct PxFEMParameters {
1913 pub velocityDamping: f32,
1914 pub settlingThreshold: f32,
1915 pub sleepThreshold: f32,
1916 pub sleepDamping: f32,
1917 pub selfCollisionFilterDistance: f32,
1918 pub selfCollisionStressTolerance: f32,
1919}
1920#[derive(Clone, Copy)]
1921#[cfg_attr(feature = "debug-structs", derive(Debug))]
1922#[repr(C)]
1923pub struct PxPruningStructure {
1924 pub structgen_pad0: [u8; 16],
1925}
1926#[derive(Clone, Copy)]
1927#[cfg_attr(feature = "debug-structs", derive(Debug))]
1928#[repr(C)]
1929pub struct PxExtendedVec3 {
1930 pub x: f64,
1931 pub y: f64,
1932 pub z: f64,
1933}
1934#[derive(Clone, Copy)]
1935#[cfg_attr(feature = "debug-structs", derive(Debug))]
1936#[repr(C)]
1937pub struct PxObstacle {
1938 pub structgen_pad0: [u8; 8],
1939 pub mUserData: *mut std::ffi::c_void,
1940 pub mPos: PxExtendedVec3,
1941 pub mRot: PxQuat,
1942}
1943#[derive(Clone, Copy)]
1944#[cfg_attr(feature = "debug-structs", derive(Debug))]
1945#[repr(C)]
1946pub struct PxBoxObstacle {
1947 pub structgen_pad0: [u8; 8],
1948 pub mUserData: *mut std::ffi::c_void,
1949 pub mPos: PxExtendedVec3,
1950 pub mRot: PxQuat,
1951 pub mHalfExtents: PxVec3,
1952 pub structgen_pad1: [u8; 4],
1953}
1954#[derive(Clone, Copy)]
1955#[cfg_attr(feature = "debug-structs", derive(Debug))]
1956#[repr(C)]
1957pub struct PxCapsuleObstacle {
1958 pub structgen_pad0: [u8; 8],
1959 pub mUserData: *mut std::ffi::c_void,
1960 pub mPos: PxExtendedVec3,
1961 pub mRot: PxQuat,
1962 pub mHalfHeight: f32,
1963 pub mRadius: f32,
1964}
1965#[derive(Clone, Copy)]
1966#[cfg_attr(feature = "debug-structs", derive(Debug))]
1967#[repr(C)]
1968pub struct PxControllerState {
1969 pub deltaXP: PxVec3,
1970 pub structgen_pad0: [u8; 4],
1971 pub touchedShape: *mut PxShape,
1972 pub touchedActor: *mut PxRigidActor,
1973 pub touchedObstacleHandle: u32,
1974 pub collisionFlags: u32,
1975 pub standOnAnotherCCT: bool,
1976 pub standOnObstacle: bool,
1977 pub isMovingUp: bool,
1978 pub structgen_pad1: [u8; 5],
1979}
1980#[derive(Clone, Copy)]
1981#[cfg_attr(feature = "debug-structs", derive(Debug))]
1982#[repr(C)]
1983pub struct PxControllerStats {
1984 pub nbIterations: u16,
1985 pub nbFullUpdates: u16,
1986 pub nbPartialUpdates: u16,
1987 pub nbTessellation: u16,
1988}
1989#[derive(Clone, Copy)]
1990#[cfg_attr(feature = "debug-structs", derive(Debug))]
1991#[repr(C)]
1992pub struct PxControllerHit {
1993 pub controller: *mut PxController,
1994 pub worldPos: PxExtendedVec3,
1995 pub worldNormal: PxVec3,
1996 pub dir: PxVec3,
1997 pub length: f32,
1998 pub structgen_pad0: [u8; 4],
1999}
2000#[derive(Clone, Copy)]
2001#[cfg_attr(feature = "debug-structs", derive(Debug))]
2002#[repr(C)]
2003pub struct PxControllerShapeHit {
2004 pub controller: *mut PxController,
2005 pub worldPos: PxExtendedVec3,
2006 pub worldNormal: PxVec3,
2007 pub dir: PxVec3,
2008 pub length: f32,
2009 pub structgen_pad0: [u8; 4],
2010 pub shape: *mut PxShape,
2011 pub actor: *mut PxRigidActor,
2012 pub triangleIndex: u32,
2013 pub structgen_pad1: [u8; 4],
2014}
2015#[derive(Clone, Copy)]
2016#[cfg_attr(feature = "debug-structs", derive(Debug))]
2017#[repr(C)]
2018pub struct PxControllersHit {
2019 pub controller: *mut PxController,
2020 pub worldPos: PxExtendedVec3,
2021 pub worldNormal: PxVec3,
2022 pub dir: PxVec3,
2023 pub length: f32,
2024 pub structgen_pad0: [u8; 4],
2025 pub other: *mut PxController,
2026}
2027#[derive(Clone, Copy)]
2028#[cfg_attr(feature = "debug-structs", derive(Debug))]
2029#[repr(C)]
2030pub struct PxControllerObstacleHit {
2031 pub controller: *mut PxController,
2032 pub worldPos: PxExtendedVec3,
2033 pub worldNormal: PxVec3,
2034 pub dir: PxVec3,
2035 pub length: f32,
2036 pub structgen_pad0: [u8; 4],
2037 pub userData: *const std::ffi::c_void,
2038}
2039#[derive(Clone, Copy)]
2040#[cfg_attr(feature = "debug-structs", derive(Debug))]
2041#[repr(C)]
2042pub struct PxControllerFilters {
2043 pub mFilterData: *const PxFilterData,
2044 pub mFilterCallback: *mut PxQueryFilterCallback,
2045 pub mFilterFlags: PxQueryFlags,
2046 pub structgen_pad0: [u8; 6],
2047 pub mCCTFilterCallback: *mut PxControllerFilterCallback,
2048}
2049#[derive(Clone, Copy)]
2050#[cfg_attr(feature = "debug-structs", derive(Debug))]
2051#[repr(C)]
2052pub struct PxControllerDesc {
2053 pub structgen_pad0: [u8; 8],
2054 pub position: PxExtendedVec3,
2055 pub upDirection: PxVec3,
2056 pub slopeLimit: f32,
2057 pub invisibleWallHeight: f32,
2058 pub maxJumpHeight: f32,
2059 pub contactOffset: f32,
2060 pub stepOffset: f32,
2061 pub density: f32,
2062 pub scaleCoeff: f32,
2063 pub volumeGrowth: f32,
2064 pub structgen_pad1: [u8; 4],
2065 pub reportCallback: *mut PxUserControllerHitReport,
2066 pub behaviorCallback: *mut PxControllerBehaviorCallback,
2067 pub nonWalkableMode: PxControllerNonWalkableMode,
2068 pub structgen_pad2: [u8; 4],
2069 pub material: *mut PxMaterial,
2070 pub registerDeletionListener: bool,
2071 pub clientID: u8,
2072 pub structgen_pad3: [u8; 6],
2073 pub userData: *mut std::ffi::c_void,
2074 pub structgen_pad4: [u8; 8],
2075}
2076#[derive(Clone, Copy)]
2077#[cfg_attr(feature = "debug-structs", derive(Debug))]
2078#[repr(C)]
2079pub struct PxBoxControllerDesc {
2080 pub structgen_pad0: [u8; 8],
2081 pub position: PxExtendedVec3,
2082 pub upDirection: PxVec3,
2083 pub slopeLimit: f32,
2084 pub invisibleWallHeight: f32,
2085 pub maxJumpHeight: f32,
2086 pub contactOffset: f32,
2087 pub stepOffset: f32,
2088 pub density: f32,
2089 pub scaleCoeff: f32,
2090 pub volumeGrowth: f32,
2091 pub structgen_pad1: [u8; 4],
2092 pub reportCallback: *mut PxUserControllerHitReport,
2093 pub behaviorCallback: *mut PxControllerBehaviorCallback,
2094 pub nonWalkableMode: PxControllerNonWalkableMode,
2095 pub structgen_pad2: [u8; 4],
2096 pub material: *mut PxMaterial,
2097 pub registerDeletionListener: bool,
2098 pub clientID: u8,
2099 pub structgen_pad3: [u8; 6],
2100 pub userData: *mut std::ffi::c_void,
2101 pub structgen_pad4: [u8; 4],
2102 pub halfHeight: f32,
2103 pub halfSideExtent: f32,
2104 pub halfForwardExtent: f32,
2105}
2106#[derive(Clone, Copy)]
2107#[cfg_attr(feature = "debug-structs", derive(Debug))]
2108#[repr(C)]
2109pub struct PxCapsuleControllerDesc {
2110 pub structgen_pad0: [u8; 8],
2111 pub position: PxExtendedVec3,
2112 pub upDirection: PxVec3,
2113 pub slopeLimit: f32,
2114 pub invisibleWallHeight: f32,
2115 pub maxJumpHeight: f32,
2116 pub contactOffset: f32,
2117 pub stepOffset: f32,
2118 pub density: f32,
2119 pub scaleCoeff: f32,
2120 pub volumeGrowth: f32,
2121 pub structgen_pad1: [u8; 4],
2122 pub reportCallback: *mut PxUserControllerHitReport,
2123 pub behaviorCallback: *mut PxControllerBehaviorCallback,
2124 pub nonWalkableMode: PxControllerNonWalkableMode,
2125 pub structgen_pad2: [u8; 4],
2126 pub material: *mut PxMaterial,
2127 pub registerDeletionListener: bool,
2128 pub clientID: u8,
2129 pub structgen_pad3: [u8; 6],
2130 pub userData: *mut std::ffi::c_void,
2131 pub structgen_pad4: [u8; 4],
2132 pub radius: f32,
2133 pub height: f32,
2134 pub climbingMode: PxCapsuleClimbingMode,
2135}
2136#[derive(Clone, Copy)]
2137#[cfg_attr(feature = "debug-structs", derive(Debug))]
2138#[repr(C)]
2139pub struct PxDim3 {
2140 pub x: u32,
2141 pub y: u32,
2142 pub z: u32,
2143}
2144#[derive(Clone, Copy)]
2145#[cfg_attr(feature = "debug-structs", derive(Debug))]
2146#[repr(C)]
2147pub struct PxSDFDesc {
2148 pub sdf: PxBoundedData,
2149 pub dims: PxDim3,
2150 pub meshLower: PxVec3,
2151 pub spacing: f32,
2152 pub subgridSize: u32,
2153 pub bitsPerSubgridPixel: PxSdfBitsPerSubgridPixel,
2154 pub sdfSubgrids3DTexBlockDim: PxDim3,
2155 pub sdfSubgrids: PxBoundedData,
2156 pub sdfStartSlots: PxBoundedData,
2157 pub subgridsMinSdfValue: f32,
2158 pub subgridsMaxSdfValue: f32,
2159 pub sdfBounds: PxBounds3,
2160 pub narrowBandThicknessRelativeToSdfBoundsDiagonal: f32,
2161 pub numThreadsForSdfConstruction: u32,
2162}
2163#[derive(Clone, Copy)]
2164#[cfg_attr(feature = "debug-structs", derive(Debug))]
2165#[repr(C)]
2166pub struct PxConvexMeshDesc {
2167 pub points: PxBoundedData,
2168 pub polygons: PxBoundedData,
2169 pub indices: PxBoundedData,
2170 pub flags: PxConvexFlags,
2171 pub vertexLimit: u16,
2172 pub polygonLimit: u16,
2173 pub quantizedCount: u16,
2174 pub sdfDesc: *mut PxSDFDesc,
2175}
2176#[derive(Clone, Copy)]
2177#[cfg_attr(feature = "debug-structs", derive(Debug))]
2178#[repr(C)]
2179pub struct PxTriangleMeshDesc {
2180 pub points: PxBoundedData,
2181 pub triangles: PxBoundedData,
2182 pub flags: PxMeshFlags,
2183 pub structgen_pad0: [u8; 22],
2184 pub sdfDesc: *mut PxSDFDesc,
2185}
2186#[derive(Clone, Copy)]
2187#[cfg_attr(feature = "debug-structs", derive(Debug))]
2188#[repr(C)]
2189pub struct PxTetrahedronMeshDesc {
2190 pub structgen_pad0: [u8; 16],
2191 pub points: PxBoundedData,
2192 pub tetrahedrons: PxBoundedData,
2193 pub flags: PxMeshFlags,
2194 pub tetsPerElement: u16,
2195 pub structgen_pad1: [u8; 4],
2196}
2197#[derive(Clone, Copy)]
2198#[cfg_attr(feature = "debug-structs", derive(Debug))]
2199#[repr(C)]
2200pub struct PxSoftBodySimulationDataDesc {
2201 pub vertexToTet: PxBoundedData,
2202}
2203#[derive(Clone, Copy)]
2204#[cfg_attr(feature = "debug-structs", derive(Debug))]
2205#[repr(C)]
2206pub struct PxBVH34MidphaseDesc {
2207 pub numPrimsPerLeaf: u32,
2208 pub buildStrategy: PxBVH34BuildStrategy,
2209 pub quantized: bool,
2210 pub structgen_pad0: [u8; 3],
2211}
2212#[derive(Clone, Copy)]
2213#[cfg_attr(feature = "debug-structs", derive(Debug))]
2214#[repr(C)]
2215pub struct PxMidphaseDesc {
2216 pub structgen_pad0: [u8; 16],
2217}
2218#[derive(Clone, Copy)]
2219#[cfg_attr(feature = "debug-structs", derive(Debug))]
2220#[repr(C)]
2221pub struct PxBVHDesc {
2222 pub bounds: PxBoundedData,
2223 pub enlargement: f32,
2224 pub numPrimsPerLeaf: u32,
2225 pub buildStrategy: PxBVHBuildStrategy,
2226 pub structgen_pad0: [u8; 4],
2227}
2228#[derive(Clone, Copy)]
2229#[cfg_attr(feature = "debug-structs", derive(Debug))]
2230#[repr(C)]
2231pub struct PxCookingParams {
2232 pub areaTestEpsilon: f32,
2233 pub planeTolerance: f32,
2234 pub convexMeshCookingType: PxConvexMeshCookingType,
2235 pub suppressTriangleMeshRemapTable: bool,
2236 pub buildTriangleAdjacencies: bool,
2237 pub buildGPUData: bool,
2238 pub structgen_pad0: [u8; 1],
2239 pub scale: PxTolerancesScale,
2240 pub meshPreprocessParams: PxMeshPreprocessingFlags,
2241 pub meshWeldTolerance: f32,
2242 pub midphaseDesc: PxMidphaseDesc,
2243 pub gaussMapLimit: u32,
2244 pub maxWeightRatioInTet: f32,
2245}
2246#[derive(Clone, Copy)]
2247#[cfg_attr(feature = "debug-structs", derive(Debug))]
2248#[repr(C)]
2249pub struct PxDefaultMemoryOutputStream {
2250 pub structgen_pad0: [u8; 32],
2251}
2252#[derive(Clone, Copy)]
2253#[cfg_attr(feature = "debug-structs", derive(Debug))]
2254#[repr(C)]
2255pub struct PxDefaultMemoryInputData {
2256 pub structgen_pad0: [u8; 32],
2257}
2258#[derive(Clone, Copy)]
2259#[cfg_attr(feature = "debug-structs", derive(Debug))]
2260#[repr(C)]
2261pub struct PxDefaultFileOutputStream {
2262 pub structgen_pad0: [u8; 16],
2263}
2264#[derive(Clone, Copy)]
2265#[cfg_attr(feature = "debug-structs", derive(Debug))]
2266#[repr(C)]
2267pub struct PxDefaultFileInputData {
2268 pub structgen_pad0: [u8; 24],
2269}
2270#[derive(Clone, Copy)]
2271#[cfg_attr(feature = "debug-structs", derive(Debug))]
2272#[repr(C)]
2273pub struct PxJoint {
2274 pub structgen_pad0: [u8; 16],
2275 pub userData: *mut std::ffi::c_void,
2276}
2277#[derive(Clone, Copy)]
2278#[cfg_attr(feature = "debug-structs", derive(Debug))]
2279#[repr(C)]
2280pub struct PxSpring {
2281 pub stiffness: f32,
2282 pub damping: f32,
2283}
2284#[derive(Clone, Copy)]
2285#[cfg_attr(feature = "debug-structs", derive(Debug))]
2286#[repr(C)]
2287pub struct PxDistanceJoint {
2288 pub structgen_pad0: [u8; 16],
2289 pub userData: *mut std::ffi::c_void,
2290}
2291#[derive(Clone, Copy)]
2292#[cfg_attr(feature = "debug-structs", derive(Debug))]
2293#[repr(C)]
2294pub struct PxJacobianRow {
2295 pub linear0: PxVec3,
2296 pub linear1: PxVec3,
2297 pub angular0: PxVec3,
2298 pub angular1: PxVec3,
2299}
2300#[derive(Clone, Copy)]
2301#[cfg_attr(feature = "debug-structs", derive(Debug))]
2302#[repr(C)]
2303pub struct PxContactJoint {
2304 pub structgen_pad0: [u8; 16],
2305 pub userData: *mut std::ffi::c_void,
2306}
2307#[derive(Clone, Copy)]
2308#[cfg_attr(feature = "debug-structs", derive(Debug))]
2309#[repr(C)]
2310pub struct PxFixedJoint {
2311 pub structgen_pad0: [u8; 16],
2312 pub userData: *mut std::ffi::c_void,
2313}
2314#[derive(Clone, Copy)]
2315#[cfg_attr(feature = "debug-structs", derive(Debug))]
2316#[repr(C)]
2317pub struct PxJointLimitParameters {
2318 pub restitution: f32,
2319 pub bounceThreshold: f32,
2320 pub stiffness: f32,
2321 pub damping: f32,
2322 pub contactDistance_deprecated: f32,
2323}
2324#[derive(Clone, Copy)]
2325#[cfg_attr(feature = "debug-structs", derive(Debug))]
2326#[repr(C)]
2327pub struct PxJointLinearLimit {
2328 pub restitution: f32,
2329 pub bounceThreshold: f32,
2330 pub stiffness: f32,
2331 pub damping: f32,
2332 pub contactDistance_deprecated: f32,
2333 pub value: f32,
2334}
2335#[derive(Clone, Copy)]
2336#[cfg_attr(feature = "debug-structs", derive(Debug))]
2337#[repr(C)]
2338pub struct PxJointLinearLimitPair {
2339 pub restitution: f32,
2340 pub bounceThreshold: f32,
2341 pub stiffness: f32,
2342 pub damping: f32,
2343 pub contactDistance_deprecated: f32,
2344 pub upper: f32,
2345 pub lower: f32,
2346}
2347#[derive(Clone, Copy)]
2348#[cfg_attr(feature = "debug-structs", derive(Debug))]
2349#[repr(C)]
2350pub struct PxJointAngularLimitPair {
2351 pub restitution: f32,
2352 pub bounceThreshold: f32,
2353 pub stiffness: f32,
2354 pub damping: f32,
2355 pub contactDistance_deprecated: f32,
2356 pub upper: f32,
2357 pub lower: f32,
2358}
2359#[derive(Clone, Copy)]
2360#[cfg_attr(feature = "debug-structs", derive(Debug))]
2361#[repr(C)]
2362pub struct PxJointLimitCone {
2363 pub restitution: f32,
2364 pub bounceThreshold: f32,
2365 pub stiffness: f32,
2366 pub damping: f32,
2367 pub contactDistance_deprecated: f32,
2368 pub yAngle: f32,
2369 pub zAngle: f32,
2370}
2371#[derive(Clone, Copy)]
2372#[cfg_attr(feature = "debug-structs", derive(Debug))]
2373#[repr(C)]
2374pub struct PxJointLimitPyramid {
2375 pub restitution: f32,
2376 pub bounceThreshold: f32,
2377 pub stiffness: f32,
2378 pub damping: f32,
2379 pub contactDistance_deprecated: f32,
2380 pub yAngleMin: f32,
2381 pub yAngleMax: f32,
2382 pub zAngleMin: f32,
2383 pub zAngleMax: f32,
2384}
2385#[derive(Clone, Copy)]
2386#[cfg_attr(feature = "debug-structs", derive(Debug))]
2387#[repr(C)]
2388pub struct PxPrismaticJoint {
2389 pub structgen_pad0: [u8; 16],
2390 pub userData: *mut std::ffi::c_void,
2391}
2392#[derive(Clone, Copy)]
2393#[cfg_attr(feature = "debug-structs", derive(Debug))]
2394#[repr(C)]
2395pub struct PxRevoluteJoint {
2396 pub structgen_pad0: [u8; 16],
2397 pub userData: *mut std::ffi::c_void,
2398}
2399#[derive(Clone, Copy)]
2400#[cfg_attr(feature = "debug-structs", derive(Debug))]
2401#[repr(C)]
2402pub struct PxSphericalJoint {
2403 pub structgen_pad0: [u8; 16],
2404 pub userData: *mut std::ffi::c_void,
2405}
2406#[derive(Clone, Copy)]
2407#[cfg_attr(feature = "debug-structs", derive(Debug))]
2408#[repr(C)]
2409pub struct PxD6JointDrive {
2410 pub stiffness: f32,
2411 pub damping: f32,
2412 pub forceLimit: f32,
2413 pub flags: PxD6JointDriveFlags,
2414}
2415#[derive(Clone, Copy)]
2416#[cfg_attr(feature = "debug-structs", derive(Debug))]
2417#[repr(C)]
2418pub struct PxD6Joint {
2419 pub structgen_pad0: [u8; 16],
2420 pub userData: *mut std::ffi::c_void,
2421}
2422#[derive(Clone, Copy)]
2423#[cfg_attr(feature = "debug-structs", derive(Debug))]
2424#[repr(C)]
2425pub struct PxGearJoint {
2426 pub structgen_pad0: [u8; 16],
2427 pub userData: *mut std::ffi::c_void,
2428}
2429#[derive(Clone, Copy)]
2430#[cfg_attr(feature = "debug-structs", derive(Debug))]
2431#[repr(C)]
2432pub struct PxRackAndPinionJoint {
2433 pub structgen_pad0: [u8; 16],
2434 pub userData: *mut std::ffi::c_void,
2435}
2436#[derive(Clone, Copy)]
2437#[cfg_attr(feature = "debug-structs", derive(Debug))]
2438#[repr(C)]
2439pub struct PxGroupsMask {
2440 pub bits0: u16,
2441 pub bits1: u16,
2442 pub bits2: u16,
2443 pub bits3: u16,
2444}
2445#[derive(Clone, Copy)]
2446#[cfg_attr(feature = "debug-structs", derive(Debug))]
2447#[repr(C)]
2448pub struct PxRigidActorExt {
2449 pub structgen_pad0: [u8; 1],
2450}
2451#[derive(Clone, Copy)]
2452#[cfg_attr(feature = "debug-structs", derive(Debug))]
2453#[repr(C)]
2454pub struct PxMassProperties {
2455 pub inertiaTensor: PxMat33,
2456 pub centerOfMass: PxVec3,
2457 pub mass: f32,
2458}
2459#[derive(Clone, Copy)]
2460#[cfg_attr(feature = "debug-structs", derive(Debug))]
2461#[repr(C)]
2462pub struct PxRigidBodyExt {
2463 pub structgen_pad0: [u8; 1],
2464}
2465#[derive(Clone, Copy)]
2466#[cfg_attr(feature = "debug-structs", derive(Debug))]
2467#[repr(C)]
2468pub struct PxShapeExt {
2469 pub structgen_pad0: [u8; 1],
2470}
2471#[derive(Clone, Copy)]
2472#[cfg_attr(feature = "debug-structs", derive(Debug))]
2473#[repr(C)]
2474pub struct PxMeshOverlapUtil {
2475 pub structgen_pad0: [u8; 1040],
2476}
2477#[derive(Clone, Copy)]
2478#[cfg_attr(feature = "debug-structs", derive(Debug))]
2479#[repr(C)]
2480pub struct PxXmlMiscParameter {
2481 pub upVector: PxVec3,
2482 pub scale: PxTolerancesScale,
2483}
2484#[derive(Clone, Copy)]
2485#[cfg_attr(feature = "debug-structs", derive(Debug))]
2486#[repr(C)]
2487pub struct PxSerialization {
2488 pub structgen_pad0: [u8; 1],
2489}
2490#[derive(Clone, Copy)]
2491#[cfg_attr(feature = "debug-structs", derive(Debug))]
2492#[repr(C)]
2493pub struct PxStringTableExt {
2494 pub structgen_pad0: [u8; 1],
2495}
2496#[derive(Clone, Copy)]
2497#[cfg_attr(feature = "debug-structs", derive(Debug))]
2498#[repr(C)]
2499pub struct PxBroadPhaseExt {
2500 pub structgen_pad0: [u8; 1],
2501}
2502#[derive(Clone, Copy)]
2503#[cfg_attr(feature = "debug-structs", derive(Debug))]
2504#[repr(C)]
2505pub struct PxSceneQueryExt {
2506 pub structgen_pad0: [u8; 1],
2507}
2508#[derive(Clone, Copy)]
2509#[cfg_attr(feature = "debug-structs", derive(Debug))]
2510#[repr(C)]
2511pub struct PxSamplingExt {
2512 pub structgen_pad0: [u8; 1],
2513}
2514#[derive(Clone, Copy)]
2515#[cfg_attr(feature = "debug-structs", derive(Debug))]
2516#[repr(C)]
2517pub struct PxPoissonSampler {
2518 pub structgen_pad0: [u8; 8],
2519}
2520#[derive(Clone, Copy)]
2521#[cfg_attr(feature = "debug-structs", derive(Debug))]
2522#[repr(C)]
2523pub struct PxTriangleMeshPoissonSampler {
2524 pub structgen_pad0: [u8; 8],
2525}
2526#[derive(Clone, Copy)]
2527#[cfg_attr(feature = "debug-structs", derive(Debug))]
2528#[repr(C)]
2529pub struct PxTetrahedronMeshExt {
2530 pub structgen_pad0: [u8; 1],
2531}
2532#[derive(Clone, Copy)]
2533#[cfg_attr(feature = "debug-structs", derive(Debug))]
2534#[repr(C)]
2535pub struct PxRepXObject {
2536 pub typeName: *const std::ffi::c_char,
2537 pub serializable: *const std::ffi::c_void,
2538 pub id: u64,
2539}
2540#[derive(Clone, Copy)]
2541#[cfg_attr(feature = "debug-structs", derive(Debug))]
2542#[repr(C)]
2543pub struct PxRepXInstantiationArgs {
2544 pub structgen_pad0: [u8; 8],
2545 pub cooker: *mut PxCooking,
2546 pub stringTable: *mut PxStringTable,
2547}
2548#[cfg(test)]
2549mod sizes {
2550 use super::*;
2551 use std::mem::size_of;
2552 #[test]
2553 fn check_sizes() {
2554 assert_eq!(size_of::<PxAllocator>(), 1);
2555 assert_eq!(size_of::<PxRawAllocator>(), 1);
2556 assert_eq!(size_of::<PxVirtualAllocator>(), 16);
2557 assert_eq!(size_of::<PxUserAllocated>(), 1);
2558 assert_eq!(size_of::<PxTempAllocator>(), 1);
2559 assert_eq!(size_of::<PxBitAndByte>(), 1);
2560 assert_eq!(size_of::<PxBitMap>(), 16);
2561 assert_eq!(size_of::<PxVec3>(), 12);
2562 assert_eq!(size_of::<PxVec3Padded>(), 16);
2563 assert_eq!(size_of::<PxQuat>(), 16);
2564 assert_eq!(size_of::<PxTransform>(), 28);
2565 assert_eq!(size_of::<PxTransformPadded>(), 32);
2566 assert_eq!(size_of::<PxMat33>(), 36);
2567 assert_eq!(size_of::<PxBounds3>(), 24);
2568 assert_eq!(size_of::<PxBroadcastingAllocator>(), 176);
2569 assert_eq!(size_of::<PxBroadcastingErrorCallback>(), 160);
2570 assert_eq!(size_of::<PxVec4>(), 16);
2571 assert_eq!(size_of::<PxMat44>(), 64);
2572 assert_eq!(size_of::<PxPlane>(), 16);
2573 assert_eq!(size_of::<Interpolation>(), 1);
2574 assert_eq!(size_of::<PxMutexImpl>(), 1);
2575 assert_eq!(size_of::<PxReadWriteLock>(), 8);
2576 assert_eq!(size_of::<PxProfileScoped>(), 40);
2577 assert_eq!(size_of::<PxSListEntry>(), 16);
2578 assert_eq!(size_of::<PxSListImpl>(), 1);
2579 assert_eq!(size_of::<PxSyncImpl>(), 1);
2580 assert_eq!(size_of::<PxCounterFrequencyToTensOfNanos>(), 16);
2581 assert_eq!(size_of::<PxTime>(), 8);
2582 assert_eq!(size_of::<PxVec2>(), 8);
2583 assert_eq!(size_of::<PxStridedData>(), 16);
2584 assert_eq!(size_of::<PxBoundedData>(), 24);
2585 assert_eq!(size_of::<PxDebugPoint>(), 16);
2586 assert_eq!(size_of::<PxDebugLine>(), 32);
2587 assert_eq!(size_of::<PxDebugTriangle>(), 48);
2588 assert_eq!(size_of::<PxDebugText>(), 32);
2589 assert_eq!(size_of::<PxDeserializationContext>(), 16);
2590 assert_eq!(size_of::<PxBase>(), 16);
2591 assert_eq!(size_of::<PxRefCounted>(), 16);
2592 assert_eq!(size_of::<PxTolerancesScale>(), 8);
2593 assert_eq!(size_of::<PxMetaDataEntry>(), 40);
2594 assert_eq!(size_of::<PxBaseTask>(), 24);
2595 assert_eq!(size_of::<PxTask>(), 32);
2596 assert_eq!(size_of::<PxLightCpuTask>(), 40);
2597 assert_eq!(size_of::<PxGeometry>(), 8);
2598 assert_eq!(size_of::<PxBoxGeometry>(), 20);
2599 assert_eq!(size_of::<PxBVH>(), 16);
2600 assert_eq!(size_of::<PxCapsuleGeometry>(), 16);
2601 assert_eq!(size_of::<PxHullPolygon>(), 20);
2602 assert_eq!(size_of::<PxConvexMesh>(), 16);
2603 assert_eq!(size_of::<PxMeshScale>(), 28);
2604 assert_eq!(size_of::<PxConvexMeshGeometry>(), 56);
2605 assert_eq!(size_of::<PxSphereGeometry>(), 12);
2606 assert_eq!(size_of::<PxPlaneGeometry>(), 8);
2607 assert_eq!(size_of::<PxTriangleMeshGeometry>(), 48);
2608 assert_eq!(size_of::<PxHeightFieldGeometry>(), 32);
2609 assert_eq!(size_of::<PxParticleSystemGeometry>(), 12);
2610 assert_eq!(size_of::<PxHairSystemGeometry>(), 8);
2611 assert_eq!(size_of::<PxTetrahedronMeshGeometry>(), 16);
2612 assert_eq!(size_of::<PxQueryHit>(), 4);
2613 assert_eq!(size_of::<PxLocationHit>(), 36);
2614 assert_eq!(size_of::<PxGeomRaycastHit>(), 44);
2615 assert_eq!(size_of::<PxGeomOverlapHit>(), 4);
2616 assert_eq!(size_of::<PxGeomSweepHit>(), 36);
2617 assert_eq!(size_of::<PxGeomIndexPair>(), 8);
2618 assert_eq!(size_of::<PxQueryThreadContext>(), 1);
2619 assert_eq!(size_of::<PxCustomGeometryType>(), 4);
2620 assert_eq!(size_of::<PxCustomGeometry>(), 16);
2621 assert_eq!(size_of::<PxGeometryHolder>(), 56);
2622 assert_eq!(size_of::<PxGeometryQuery>(), 1);
2623 assert_eq!(size_of::<PxHeightFieldSample>(), 4);
2624 assert_eq!(size_of::<PxHeightField>(), 16);
2625 assert_eq!(size_of::<PxHeightFieldDesc>(), 40);
2626 assert_eq!(size_of::<PxMeshQuery>(), 1);
2627 assert_eq!(size_of::<PxSimpleTriangleMesh>(), 56);
2628 assert_eq!(size_of::<PxTriangle>(), 36);
2629 assert_eq!(size_of::<PxTrianglePadded>(), 40);
2630 assert_eq!(size_of::<PxTriangleMesh>(), 16);
2631 assert_eq!(size_of::<PxBVH34TriangleMesh>(), 16);
2632 assert_eq!(size_of::<PxTetrahedron>(), 48);
2633 assert_eq!(size_of::<PxSoftBodyAuxData>(), 16);
2634 assert_eq!(size_of::<PxTetrahedronMesh>(), 16);
2635 assert_eq!(size_of::<PxSoftBodyMesh>(), 16);
2636 assert_eq!(size_of::<PxCollisionMeshMappingData>(), 8);
2637 assert_eq!(size_of::<PxSoftBodyCollisionData>(), 1);
2638 assert_eq!(size_of::<PxTetrahedronMeshData>(), 1);
2639 assert_eq!(size_of::<PxSoftBodySimulationData>(), 1);
2640 assert_eq!(size_of::<PxCollisionTetrahedronMeshData>(), 8);
2641 assert_eq!(size_of::<PxSimulationTetrahedronMeshData>(), 8);
2642 assert_eq!(size_of::<PxActor>(), 24);
2643 assert_eq!(size_of::<PxAggregate>(), 24);
2644 assert_eq!(size_of::<PxSpringModifiers>(), 16);
2645 assert_eq!(size_of::<PxRestitutionModifiers>(), 16);
2646 assert_eq!(size_of::<Px1DConstraint>(), 96);
2647 assert_eq!(size_of::<PxConstraintInvMassScale>(), 16);
2648 assert_eq!(size_of::<PxContactPoint>(), 80);
2649 assert_eq!(size_of::<PxSolverBody>(), 32);
2650 assert_eq!(size_of::<PxSolverBodyData>(), 112);
2651 assert_eq!(size_of::<PxConstraintBatchHeader>(), 8);
2652 assert_eq!(size_of::<PxSolverConstraintDesc>(), 64);
2653 assert_eq!(size_of::<PxSolverConstraintPrepDescBase>(), 128);
2654 assert_eq!(size_of::<PxSolverConstraintPrepDesc>(), 192);
2655 assert_eq!(size_of::<PxSolverContactDesc>(), 208);
2656 assert_eq!(size_of::<PxArticulationLimit>(), 8);
2657 assert_eq!(size_of::<PxArticulationDrive>(), 16);
2658 assert_eq!(size_of::<PxTGSSolverBodyVel>(), 64);
2659 assert_eq!(size_of::<PxTGSSolverBodyTxInertia>(), 64);
2660 assert_eq!(size_of::<PxTGSSolverBodyData>(), 48);
2661 assert_eq!(size_of::<PxTGSSolverConstraintPrepDescBase>(), 144);
2662 assert_eq!(size_of::<PxTGSSolverConstraintPrepDesc>(), 224);
2663 assert_eq!(size_of::<PxTGSSolverContactDesc>(), 224);
2664 assert_eq!(size_of::<PxArticulationTendonLimit>(), 8);
2665 assert_eq!(size_of::<PxArticulationAttachment>(), 24);
2666 assert_eq!(size_of::<PxArticulationTendonJoint>(), 24);
2667 assert_eq!(size_of::<PxArticulationTendon>(), 24);
2668 assert_eq!(size_of::<PxArticulationSpatialTendon>(), 24);
2669 assert_eq!(size_of::<PxArticulationFixedTendon>(), 24);
2670 assert_eq!(size_of::<PxSpatialForce>(), 32);
2671 assert_eq!(size_of::<PxSpatialVelocity>(), 32);
2672 assert_eq!(size_of::<PxArticulationRootLinkData>(), 76);
2673 assert_eq!(size_of::<PxArticulationCache>(), 136);
2674 assert_eq!(size_of::<PxArticulationSensor>(), 24);
2675 assert_eq!(size_of::<PxArticulationReducedCoordinate>(), 24);
2676 assert_eq!(size_of::<PxArticulationJointReducedCoordinate>(), 24);
2677 assert_eq!(size_of::<PxShape>(), 24);
2678 assert_eq!(size_of::<PxRigidActor>(), 24);
2679 assert_eq!(size_of::<PxNodeIndex>(), 8);
2680 assert_eq!(size_of::<PxRigidBody>(), 24);
2681 assert_eq!(size_of::<PxArticulationLink>(), 24);
2682 assert_eq!(size_of::<PxConeLimitedConstraint>(), 24);
2683 assert_eq!(size_of::<PxConeLimitParams>(), 32);
2684 assert_eq!(size_of::<PxConstraintShaderTable>(), 32);
2685 assert_eq!(size_of::<PxConstraint>(), 24);
2686 assert_eq!(size_of::<PxMassModificationProps>(), 16);
2687 assert_eq!(size_of::<PxContactPatch>(), 64);
2688 assert_eq!(size_of::<PxContact>(), 16);
2689 assert_eq!(size_of::<PxExtendedContact>(), 32);
2690 assert_eq!(size_of::<PxModifiableContact>(), 64);
2691 assert_eq!(size_of::<PxContactStreamIterator>(), 80);
2692 assert_eq!(size_of::<PxGpuContactPair>(), 72);
2693 assert_eq!(size_of::<PxContactSet>(), 16);
2694 assert_eq!(size_of::<PxContactModifyPair>(), 104);
2695 assert_eq!(size_of::<PxBaseMaterial>(), 24);
2696 assert_eq!(size_of::<PxFEMMaterial>(), 24);
2697 assert_eq!(size_of::<PxFilterData>(), 16);
2698 assert_eq!(size_of::<PxParticleRigidFilterPair>(), 16);
2699 assert_eq!(size_of::<PxMaterial>(), 24);
2700 assert_eq!(size_of::<PxGpuParticleBufferIndexPair>(), 8);
2701 assert_eq!(size_of::<PxParticleVolume>(), 32);
2702 assert_eq!(size_of::<PxDiffuseParticleParams>(), 40);
2703 assert_eq!(size_of::<PxParticleSpring>(), 24);
2704 assert_eq!(size_of::<PxParticleMaterial>(), 24);
2705 assert_eq!(size_of::<PxActorShape>(), 16);
2706 assert_eq!(size_of::<PxRaycastHit>(), 64);
2707 assert_eq!(size_of::<PxOverlapHit>(), 24);
2708 assert_eq!(size_of::<PxSweepHit>(), 56);
2709 assert_eq!(size_of::<PxRaycastCallback>(), 96);
2710 assert_eq!(size_of::<PxOverlapCallback>(), 56);
2711 assert_eq!(size_of::<PxSweepCallback>(), 88);
2712 assert_eq!(size_of::<PxRaycastBuffer>(), 96);
2713 assert_eq!(size_of::<PxOverlapBuffer>(), 56);
2714 assert_eq!(size_of::<PxSweepBuffer>(), 88);
2715 assert_eq!(size_of::<PxQueryCache>(), 24);
2716 assert_eq!(size_of::<PxQueryFilterData>(), 20);
2717 assert_eq!(size_of::<PxRigidDynamic>(), 24);
2718 assert_eq!(size_of::<PxRigidStatic>(), 24);
2719 assert_eq!(size_of::<PxSceneQueryDesc>(), 36);
2720 assert_eq!(size_of::<PxBroadPhaseRegion>(), 32);
2721 assert_eq!(size_of::<PxBroadPhaseRegionInfo>(), 48);
2722 assert_eq!(size_of::<PxBroadPhaseCaps>(), 4);
2723 assert_eq!(size_of::<PxBroadPhaseDesc>(), 32);
2724 assert_eq!(size_of::<PxBroadPhaseUpdateData>(), 80);
2725 assert_eq!(size_of::<PxBroadPhasePair>(), 8);
2726 assert_eq!(size_of::<PxBroadPhaseResults>(), 32);
2727 assert_eq!(size_of::<PxSceneLimits>(), 32);
2728 assert_eq!(size_of::<PxgDynamicsMemoryConfig>(), 48);
2729 assert_eq!(size_of::<PxSceneDesc>(), 352);
2730 assert_eq!(size_of::<PxSimulationStatistics>(), 2232);
2731 assert_eq!(size_of::<PxGpuBodyData>(), 64);
2732 assert_eq!(size_of::<PxGpuActorPair>(), 16);
2733 assert_eq!(size_of::<PxIndexDataPair>(), 16);
2734 assert_eq!(size_of::<PxDominanceGroupPair>(), 2);
2735 assert_eq!(size_of::<PxScene>(), 16);
2736 assert_eq!(size_of::<PxSceneReadLock>(), 8);
2737 assert_eq!(size_of::<PxSceneWriteLock>(), 8);
2738 assert_eq!(size_of::<PxContactPairExtraDataItem>(), 1);
2739 assert_eq!(size_of::<PxContactPairVelocity>(), 52);
2740 assert_eq!(size_of::<PxContactPairPose>(), 60);
2741 assert_eq!(size_of::<PxContactPairIndex>(), 4);
2742 assert_eq!(size_of::<PxContactPairExtraDataIterator>(), 48);
2743 assert_eq!(size_of::<PxContactPairHeader>(), 48);
2744 assert_eq!(size_of::<PxContactPairPoint>(), 48);
2745 assert_eq!(size_of::<PxContactPair>(), 64);
2746 assert_eq!(size_of::<PxTriggerPair>(), 40);
2747 assert_eq!(size_of::<PxConstraintInfo>(), 24);
2748 assert_eq!(size_of::<PxFEMParameters>(), 24);
2749 assert_eq!(size_of::<PxPruningStructure>(), 16);
2750 assert_eq!(size_of::<PxExtendedVec3>(), 24);
2751 assert_eq!(size_of::<PxObstacle>(), 56);
2752 assert_eq!(size_of::<PxBoxObstacle>(), 72);
2753 assert_eq!(size_of::<PxCapsuleObstacle>(), 64);
2754 assert_eq!(size_of::<PxControllerState>(), 48);
2755 assert_eq!(size_of::<PxControllerStats>(), 8);
2756 assert_eq!(size_of::<PxControllerHit>(), 64);
2757 assert_eq!(size_of::<PxControllerShapeHit>(), 88);
2758 assert_eq!(size_of::<PxControllersHit>(), 72);
2759 assert_eq!(size_of::<PxControllerObstacleHit>(), 72);
2760 assert_eq!(size_of::<PxControllerFilters>(), 32);
2761 assert_eq!(size_of::<PxControllerDesc>(), 136);
2762 assert_eq!(size_of::<PxBoxControllerDesc>(), 144);
2763 assert_eq!(size_of::<PxCapsuleControllerDesc>(), 144);
2764 assert_eq!(size_of::<PxDim3>(), 12);
2765 assert_eq!(size_of::<PxSDFDesc>(), 160);
2766 assert_eq!(size_of::<PxConvexMeshDesc>(), 88);
2767 assert_eq!(size_of::<PxTriangleMeshDesc>(), 80);
2768 assert_eq!(size_of::<PxTetrahedronMeshDesc>(), 72);
2769 assert_eq!(size_of::<PxSoftBodySimulationDataDesc>(), 24);
2770 assert_eq!(size_of::<PxBVH34MidphaseDesc>(), 12);
2771 assert_eq!(size_of::<PxMidphaseDesc>(), 16);
2772 assert_eq!(size_of::<PxBVHDesc>(), 40);
2773 assert_eq!(size_of::<PxCookingParams>(), 56);
2774 assert_eq!(size_of::<PxDefaultMemoryOutputStream>(), 32);
2775 assert_eq!(size_of::<PxDefaultMemoryInputData>(), 32);
2776 assert_eq!(size_of::<PxDefaultFileOutputStream>(), 16);
2777 assert_eq!(size_of::<PxDefaultFileInputData>(), 24);
2778 assert_eq!(size_of::<PxJoint>(), 24);
2779 assert_eq!(size_of::<PxSpring>(), 8);
2780 assert_eq!(size_of::<PxDistanceJoint>(), 24);
2781 assert_eq!(size_of::<PxJacobianRow>(), 48);
2782 assert_eq!(size_of::<PxContactJoint>(), 24);
2783 assert_eq!(size_of::<PxFixedJoint>(), 24);
2784 assert_eq!(size_of::<PxJointLimitParameters>(), 20);
2785 assert_eq!(size_of::<PxJointLinearLimit>(), 24);
2786 assert_eq!(size_of::<PxJointLinearLimitPair>(), 28);
2787 assert_eq!(size_of::<PxJointAngularLimitPair>(), 28);
2788 assert_eq!(size_of::<PxJointLimitCone>(), 28);
2789 assert_eq!(size_of::<PxJointLimitPyramid>(), 36);
2790 assert_eq!(size_of::<PxPrismaticJoint>(), 24);
2791 assert_eq!(size_of::<PxRevoluteJoint>(), 24);
2792 assert_eq!(size_of::<PxSphericalJoint>(), 24);
2793 assert_eq!(size_of::<PxD6JointDrive>(), 16);
2794 assert_eq!(size_of::<PxD6Joint>(), 24);
2795 assert_eq!(size_of::<PxGearJoint>(), 24);
2796 assert_eq!(size_of::<PxRackAndPinionJoint>(), 24);
2797 assert_eq!(size_of::<PxGroupsMask>(), 8);
2798 assert_eq!(size_of::<PxRigidActorExt>(), 1);
2799 assert_eq!(size_of::<PxMassProperties>(), 52);
2800 assert_eq!(size_of::<PxRigidBodyExt>(), 1);
2801 assert_eq!(size_of::<PxShapeExt>(), 1);
2802 assert_eq!(size_of::<PxMeshOverlapUtil>(), 1040);
2803 assert_eq!(size_of::<PxXmlMiscParameter>(), 20);
2804 assert_eq!(size_of::<PxSerialization>(), 1);
2805 assert_eq!(size_of::<PxStringTableExt>(), 1);
2806 assert_eq!(size_of::<PxBroadPhaseExt>(), 1);
2807 assert_eq!(size_of::<PxSceneQueryExt>(), 1);
2808 assert_eq!(size_of::<PxSamplingExt>(), 1);
2809 assert_eq!(size_of::<PxPoissonSampler>(), 8);
2810 assert_eq!(size_of::<PxTriangleMeshPoissonSampler>(), 8);
2811 assert_eq!(size_of::<PxTetrahedronMeshExt>(), 1);
2812 assert_eq!(size_of::<PxRepXObject>(), 24);
2813 assert_eq!(size_of::<PxRepXInstantiationArgs>(), 24);
2814 }
2815}